diff --git a/.claude/skills/add-remote-endpoint/SKILL.md b/.claude/skills/add-remote-endpoint/SKILL.md
index 5783ded148..fdba33fe90 100644
--- a/.claude/skills/add-remote-endpoint/SKILL.md
+++ b/.claude/skills/add-remote-endpoint/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: add-remote-endpoint
-description: Use when adding a new remote/network endpoint (a RemoteOperation / OCSRemoteOperation) to this Nextcloud Android library, or when the user says "add an endpoint", "new remote operation", "implement this API call", or "wire up <OCS/ocs> API". Scaffolds the models, constants, operation, and tests following the governance package conventions and the standards in AGENTS.md.
+description: Use when adding a new remote/network endpoint (a RemoteOperation on OcsKotlinRemoteOperation) to this Nextcloud Android library, or when the user says "add an endpoint", "new remote operation", "implement this API call", "create endpoints for <feature>", or "wire up <OCS/ocs> API". Scopes the calls to the client flow, then scaffolds verb/sub-feature packages, models, operations and integration tests following the teams package conventions and the standards in AGENTS.md.
 ---
 
 <!--
@@ -10,78 +10,130 @@ description: Use when adding a new remote/network endpoint (a RemoteOperation /
 
 # Add a remote endpoint
 
-Implement a new `RemoteOperation` for this library the way the existing ones are written. The full,
+Implement new `RemoteOperation`s for this library the way the existing ones are written. The full,
 authoritative standards live in **[AGENTS.md](../../../AGENTS.md)** — this skill is the step-by-step
 procedure. When they disagree, AGENTS.md wins.
 
 ## 0. Ground yourself in the reference
 
-Read the canonical package before writing anything:
+Read before writing anything:
 
-- `library/src/main/java/com/nextcloud/android/lib/resources/governance/` — operations (GET/POST/DELETE)
-- `library/src/main/java/com/nextcloud/android/lib/resources/governance/model/` — `@Serializable` models + enums
-- `library/src/main/java/com/owncloud/android/lib/ocs/OcsResponse.kt` — shared `OcsResponse<T>`, `ocsJson`, `SEPARATOR`
+- `library/src/main/java/com/nextcloud/operations/OcsKotlinRemoteOperation.kt` — the base class every
+  OCS operation extends (call, guard, decode, logging, release).
+- `library/src/main/java/com/nextcloud/android/lib/resources/teams/` — the canonical feature:
+  verb/sub-feature packages, model placement, `createMethod` + `parse` operations.
+- `library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/` — one `*IT` per operation.
 
-Pick the existing operation closest to the one you're adding (list-returning GET, single-object GET,
-POST with body, DELETE) and mirror its structure.
+Do **not** use `resources/governance/` as a template; it predates the base class.
 
-## 1. Confirm the contract
+## 1. Scope the calls to the flow
 
-Establish, from the user or the API: HTTP method, path (base + segments), path/query params, request
-body shape (if any), and the JSON response shape. If any of these is unclear, ask before coding.
+Ask for (or extract from the issue) the client flow: the screens and user actions. List each step and
+map it to the one server call it needs. Implement only those calls.
 
-## 2. Models — under `<feature>.model`
+- Server/web-frontend API files (e.g. a `api.ts`) list far more than a mobile flow needs. Don't port
+  them wholesale.
+- Leave out admin-only endpoints, other apps' APIs and calls the library already has (WebDAV, sharees).
+- Name skipped-but-related calls to the human as possible follow-ups instead of implementing them.
 
-For each new wire type create a Kotlin `@Serializable data class` (or `enum` with `@SerialName`) in
-`com.nextcloud.android.lib.resources.<feature>.model`. Never put models beside the operation or in an
-unrelated package. Reuse the shared `OcsResponse<T>` envelope — do not model the `ocs`/`data`/`meta`
-wrapper yourself.
+If the flow is unclear, ask before coding.
 
-## 3. Constants
+## 2. Confirm each contract against the server
 
-- Reuse `com.owncloud.android.lib.ocs.SEPARATOR` for `"/"` — never inline it.
-- Put the base path and each path segment in the operation's `companion object` as `private const val`
-  (`ENDPOINT`, `AVAILABLE`, …). No hardcoded endpoint strings, param keys, or headers.
+For every call, read the server controller (and `routes.php` / `#[ApiRoute]`) at the relevant commit:
 
-## 4. Operation
+- HTTP verb and full path (`/ocs/v2.php/apps/<app>/…` or core `/ocs/v2.php/<area>/…`)
+- request parameters / JSON body field names and types
+- the exact `DataResponse` shape: which fields always exist, which can be `null`, whether `data` is an
+  object, a list, or an object wrapping a list
+- non-200 cases the client should know about (e.g. 404 when nothing is linked)
 
-Extend `OCSRemoteOperation<T>` and follow the template in AGENTS.md exactly:
+## 3. Plan the packages
 
-- `@Suppress("TooGenericExceptionCaught")` on `run()`.
-- Build the method (`GetMethod`/`PostMethod`/`DeleteMethod`), then `return try { … } catch (e: Exception) { failure(e) } finally { method.releaseConnection() }`.
-- Guard clause first: `if (status != HttpStatus.SC_OK) return RemoteOperationResult(false, method)`.
-  No nested if/else; keep the body linear.
-- Decode with `ocsJson.decodeFromString<OcsResponse<T>>(method.getResponseBodyAsString()).ocs.data`.
-- Success: `RemoteOperationResult<T>(true, method).apply { resultData = data }` (property, not a setter).
-- Keep **≤ 2 `return` keywords** total (guard + `return try`). The success and `failure` values are
-  expressions, not returns.
-- Add the `private fun failure(e: Exception)` helper with `@Suppress("DEPRECATION")` (for `logMessage`)
-  that logs via `Log_OC.e` and returns `RemoteOperationResult(e)`.
-- No class-level KDoc that just restates the class name.
+```
+resources/<feature>/
+  model/                          shared by more than one inner package
+  <verb>/<subfeature>/            the operation
+  <verb>/<subfeature>/model/      models only that operation uses
+```
+
+`<verb>` is `get` / `post` / `put` / `delete`; `<subfeature>` is a short noun (`team`, `members`,
+`folder`). For each model, list which operations use it, then place it in the narrowest package that
+covers all of them. Never one big `<feature>/model` package.
+
+## 4. Models
+
+- `@Serializable data class` per wire type, one public type per file; enums with `@SerialName`.
+- Required fields for what the server always sends; defaults/nullable only for what it can omit or
+  null.
+- Request bodies: `internal @Serializable` classes, **no default values** (`ocsJson` drops defaults).
+- Response wrappers that only exist to match the wire (`{ "resources": [...] }`): `internal`.
+- Computed helpers for server semantics the flow needs (`Team.isMember`, `TeamMember.role`).
+- Numeric enum wire values: file-level `private const val`s (detekt `MagicNumber`).
+- No comments or KDoc.
+
+## 5. Operation
+
+Extend `OcsKotlinRemoteOperation<T>`; implement only `createMethod` and `parse`, plus companion
+constants:
+
+```kotlin
+class GetTeamFolderRemoteOperation(
+    private val teamId: String
+) : OcsKotlinRemoteOperation<TeamFolder>() {
+    override fun createMethod(baseUrl: String) =
+        GetMethod(baseUrl + ENDPOINT + SEPARATOR + teamId + FOLDER + JSON_FORMAT, true)
+
+    override fun parse(body: String) = decode(body, TeamFolder.serializer())
 
-## 5. Tests
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/teams"
+        private const val FOLDER = "/folder"
+    }
+}
+```
+
+- List: `decode(body, ListSerializer(X.serializer()))`.
+- Wrapper: `decode(body, XResponse.serializer()).items`.
+- Body: `PostMethod(url, true, jsonBody(XRequest(...), XRequest.serializer()))`.
+- Nothing to return: `OcsKotlinRemoteOperation<Void>` with `override fun parse(body: String): Void? = null`.
+- Reuse `SEPARATOR`; every path segment is a `private const val`; `JSON_FORMAT` is inherited.
+- Never override `run()`. If the base class can't express something, extend the base class once.
+- No comments or KDoc. License header with the author's own name and e-mail.
+
+## 6. Integration tests
+
+No parsing unit tests. One `*IT` per operation, same package layout under
+`library/src/androidTest/java/com/nextcloud/android/lib/resources/<feature>/<verb>/<subfeature>/`:
+
+- `class XRemoteOperationIT : AbstractIT()`, gated with `testOnlyOnServer(NextcloudVersion.nextcloud_XX)`
+  (existing constant).
+- Create the data the test needs with the library's own operations, using unique names.
+- Assert `isSuccess`, the important `resultData` fields, and `httpCode` for expected failures.
+- `nextcloudClient` is the non-admin `test` user on CI; use `client2` only for admin-only endpoints.
 
-Add unit tests beside the existing ones in
-`library/src/test/java/com/nextcloud/android/lib/resources/<feature>/`, mirroring the governance
-parsing tests — feed a sample OCS JSON string through `ocsJson.decodeFromString<OcsResponse<…>>(json)`
-and assert the decoded fields.
+## 7. Stay inside the feature
 
-Add integration test that makes the actual API call and add an instrumented test under
-`library/src/androidTest/java/com/nextcloud/android/lib/resources/<feature>/` that runs the operation
-against a live server and asserts the `RemoteOperationResult` (mirror the existing `*IT` tests).
+Don't touch `.github/` workflows, `NextcloudVersion` or other shared files as part of the endpoint
+task. If CI lacks an app the tests need, tell the human.
 
-## 6. Verify
+## 8. Verify
 
-Verify — `detekt`, `spotlessKotlinCheck`, and `lint` (see `.github/workflows/check.yml`):
+While working, compile only:
 
 ```bash
 ./gradlew :library:compileDebugKotlin
-./gradlew :library:testDebugUnitTest --tests "com.nextcloud.android.lib.resources.<feature>.*"
+./gradlew :library:compileDebugAndroidTestKotlin
+```
+
+Present the result for review. After the human agrees, run the CI checks once
+(`.github/workflows/check.yml`):
+
+```bash
 ./gradlew :library:detekt
 ./gradlew :library:spotlessKotlinCheck
 ./gradlew :library:lint
 ```
 
-All must pass. Check lines are ≤ 120 (spotless check can't always be relied on locally — see
-AGENTS.md). Then review the diff against the "Definition of done" checklist in AGENTS.md and remove
-anything unrelated.
+All three must pass (spotless runs locally, like in CI). Then review the
+diff against the "Definition of done" checklist in AGENTS.md and remove anything unrelated.
diff --git a/AGENTS.md b/AGENTS.md
index dc90f0109f..c417fe82ff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -27,21 +27,42 @@ Material Design concerns. Everything is request → response → typed result.
 ## Project Structure: AI Agent Handling Guidelines
 
 - **Legacy package (`owncloud`):** `library/src/main/java/com/owncloud/android/lib/`
-  - Shared OCS types live here: `com.owncloud.android.lib.ocs` — `OcsResponse<T>` / `Ocs<T>`
-    envelope, `ocsJson` (the strict shared `Json`), `SEPARATOR` (`"/"`).
+  - Shared OCS types live here: `com.owncloud.android.lib.ocs` — `OcsKotlinResponse<T>` /
+    `OcsKotlin<T>` envelope, `ocsJson` (the strict shared `Json`), `SEPARATOR` (`"/"`).
 - **Modern package (`nextcloud`):** `library/src/main/java/com/nextcloud/android/lib/`
-  - Remote operations: `…/resources/<feature>/`
-  - Wire models/enums: `…/resources/<feature>/model/`
+  - Remote operations: `…/resources/<feature>/<verb>/<subfeature>/`
+  - Wire models/enums: next to the operation that uses them (see [Package structure](#package-structure))
+- **Base class for OCS operations:** `com.nextcloud.operations.OcsKotlinRemoteOperation<T>`
 - **Canonical reference implementation:**
-  `library/src/main/java/com/nextcloud/android/lib/resources/governance/`
-- **Tests:**
-  - Unit tests: `library/src/test/java/…`
-  - Instrumented / integration tests (real API calls): `library/src/androidTest/java/…`
+  `library/src/main/java/com/nextcloud/android/lib/resources/teams/`
+  - `resources/governance/` predates the base class. Do not copy its hand-written `run()` bodies.
+- **Tests:** instrumented / integration tests (real API calls): `library/src/androidTest/java/…`
 
-**Before writing anything, read an existing endpoint and copy its shape.** Copy the *architecture*,
+**Before writing anything, read `resources/teams/` and copy its shape.** Copy the *architecture*,
 not the text. Do not invent new patterns unless a requirement genuinely cannot be met with the
 existing one.
 
+## Scope: build only what the flow needs
+
+Endpoints are added for a concrete client flow (an issue, a screen list, a user story), not to mirror
+every call a server or web-frontend API file exposes.
+
+1. Write down the flow's steps (e.g. "see my teams", "create a team", "open the team folder").
+2. Map each step to the **one** server call that serves it. Read the server controller to confirm the
+   route, the HTTP method, the request body and the exact response shape.
+3. Implement only those calls and only the model fields and helpers those steps use.
+4. Skip admin-only endpoints, other apps' APIs, WebDAV calls the library already has, and anything
+   "nice to have". Mention possible follow-ups to the human instead of implementing them.
+
+Example — the Teams flow (list teams, create team, see what's shared, manage members, open settings,
+open team folder, open Talk chat) needs exactly six operations: `GetTeams`, `GetTeamMembers`,
+`GetTeamResources`, `GetTeamFolder`, `CreateTeam`, `AddTeamMembers`. Favourites, tab order, dashboard
+previews, join/leave/delete and folder linking were deliberately left out.
+
+**Stay inside the feature.** An endpoint task does not change CI workflows (`.github/`),
+`NextcloudVersion`, or other shared files as a side effect. If the feature genuinely needs such a
+change, ask the human first.
+
 ## General Guidance
 
 - **One public type per source file.**
@@ -72,175 +93,193 @@ existing one.
 - The compiler plugin is already applied in `library/build.gradle`
   (`org.jetbrains.kotlin.plugin.serialization`). Every model that crosses the wire is `@Serializable`.
 - Enum wire values use `@SerialName`.
-- Decode with the shared strict parser, never a new `Json { }`:
-
-```kotlin
-import com.owncloud.android.lib.ocs.OcsResponse   // { "ocs": { "data": T } } envelope
-import com.owncloud.android.lib.ocs.ocsJson        // Json { ignoreUnknownKeys = true }
-
-val response = ocsJson.decodeFromString<OcsResponse<EntityLabels>>(method.getResponseBodyAsString())
-val data = response.ocs.data
-```
+- Never create a new `Json { }`. `OcsKotlinRemoteOperation` decodes and encodes with the shared strict
+  `ocsJson` through its `decode(...)` and `jsonBody(...)` helpers.
+- Request bodies are dedicated `internal @Serializable` request classes (`CreateTeamRequest`), never
+  hand-built JSON strings or maps. Do **not** give request fields default values: `ocsJson` does not
+  encode defaults, so a defaulted field silently disappears from the body.
+- Response model fields that the server always sends are required. Give a default (or make nullable)
+  only when the server can omit the field or send `null`.
 
 `ocsJson` is strict on purpose (fail fast): unknown keys are ignored, but a missing/mismatched
 required field throws instead of yielding a half-populated object.
 
 ## Package structure
 
-New endpoints live under `com.nextcloud.android.lib.resources.<feature>`. **Models used by remote
-operations go in a `<feature>.model` subpackage** — never beside the operations, never in an unrelated
-package. Reusable, cross-endpoint types (the OCS envelope, `ocsJson`, `SEPARATOR`) live in
-`com.owncloud.android.lib.ocs`.
+New endpoints live under `com.nextcloud.android.lib.resources.<feature>`. Inside a feature,
+operations are grouped **by HTTP verb, then by sub-feature**, and every model lives in the
+**narrowest package that uses it**:
 
 ```
-resources/governance/
- ├── GetEntityLabelsRemoteOperation.kt      # operations
- ├── SetLabelRemoteOperation.kt
- ├── …
- └── model/                                 # data classes + enums
-     ├── EntityLabels.kt
-     ├── HoldLabelInfo.kt
-     ├── LabelType.kt
-     └── …
+resources/teams/
+ ├── model/                                   # shared: used by more than one inner package
+ │   ├── Team.kt                              #   (GetTeams + CreateTeam)
+ │   ├── TeamMember.kt                        #   (Team.initiator + GetTeamMembers)
+ │   ├── TeamMemberType.kt
+ │   └── TeamRole.kt
+ ├── get/
+ │   ├── team/GetTeamsRemoteOperation.kt
+ │   ├── members/GetTeamMembersRemoteOperation.kt
+ │   ├── folder/
+ │   │   ├── GetTeamFolderRemoteOperation.kt
+ │   │   └── model/TeamFolder.kt              # only used by GetTeamFolder
+ │   └── resources/
+ │       ├── GetTeamResourcesRemoteOperation.kt
+ │       └── model/
+ │           ├── TeamResource.kt
+ │           ├── TeamResourceProvider.kt
+ │           └── TeamResourcesResponse.kt     # internal wrapper, unwrapped in parse()
+ └── post/
+     ├── team/
+     │   ├── CreateTeamRemoteOperation.kt
+     │   └── model/CreateTeamRequest.kt
+     └── members/
+         ├── AddTeamMembersRemoteOperation.kt
+         └── model/
+             ├── AddTeamMemberRequest.kt
+             ├── AddTeamMembersRequest.kt
+             └── NewTeamMember.kt
 ```
 
-Create dedicated `Request` / `Response` / model / enum classes when appropriate. Do not reuse
-unrelated models just to avoid a new file, and do not expose internal models as API contracts.
+Rules:
+
+- Verb packages: `get`, `post`, `put`, `delete`. Sub-feature packages are short nouns (`team`,
+  `members`, `folder`, `resources`).
+- A model used by **one** sub-feature goes in `<feature>/<verb>/<subfeature>/model/`.
+- A model used by **more than one** inner package goes in `<feature>/model/`. Never put every model
+  into one big `<feature>/model` package "just in case".
+- Request bodies and response wrappers that exist only to match the wire format are `internal`.
+  Expose clean public types (`List<TeamResource>`, not `TeamResourcesResponse`).
+- Small derived helpers that encode server semantics belong on the model as computed properties
+  (`Team.isMember`, `TeamMember.role`, `TeamMemberType.fromShareType(...)`) so every client app does
+  not re-implement them. Only add the ones the flow uses.
+- Reusable cross-feature types (the OCS envelope, `ocsJson`, `SEPARATOR`) stay in
+  `com.owncloud.android.lib.ocs`.
 
 ## Remote operation pattern
 
-Every operation extends `OCSRemoteOperation<T>` and follows this exact shape (this is
-`GetAvailableHoldLabelsRemoteOperation`, the canonical template):
+Every OCS operation extends **`com.nextcloud.operations.OcsKotlinRemoteOperation<T>`**. The base class
+owns the whole call: execute, non-200 guard, decode of the `{ "ocs": { "data": … } }` envelope,
+`RemoteOperationResult` creation, the single `catch` + logging (tagged with the subclass name) and
+`releaseConnection()`. A subclass only says **what to send** and **how to read the answer**:
+
+| Member | Purpose |
+|---|---|
+| `createMethod(baseUrl)` | Build the `GetMethod` / `PostMethod` / `PutMethod` / `DeleteMethod` with the full URL. |
+| `parse(body)` | Turn the response body into `T` (usually one `decode(...)` call). |
+| `decode(body, serializer)` | Helper: decode `ocs.data` with `ocsJson`. |
+| `jsonBody(value, serializer)` | Helper: encode a request object as an `application/json` body. |
+
+GET returning a model (`GetTeamFolderRemoteOperation`):
 
 ```kotlin
-package com.nextcloud.android.lib.resources.governance
-
-import com.nextcloud.android.lib.resources.governance.model.HoldLabelInfo
-import com.nextcloud.common.NextcloudClient
-import com.nextcloud.operations.GetMethod
-import com.owncloud.android.lib.common.operations.RemoteOperationResult
-import com.owncloud.android.lib.common.utils.Log_OC
-import com.owncloud.android.lib.ocs.OcsResponse
-import com.owncloud.android.lib.ocs.SEPARATOR
-import com.owncloud.android.lib.ocs.ocsJson
-import com.owncloud.android.lib.resources.OCSRemoteOperation
-import org.apache.commons.httpclient.HttpStatus
-
-class GetAvailableHoldLabelsRemoteOperation(
-    private val entityType: String,
-    private val entityId: Long
-) : OCSRemoteOperation<List<HoldLabelInfo>>() {
-    @Suppress("TooGenericExceptionCaught")
-    override fun run(client: NextcloudClient): RemoteOperationResult<List<HoldLabelInfo>> {
-        val getMethod =
-            GetMethod(
-                client.baseUri.toString() + ENDPOINT + entityType + SEPARATOR + entityId +
-                    HOLD_AVAILABLE + JSON_FORMAT,
-                true
-            )
-        return try {
-            val status = client.execute(getMethod)
-            if (status != HttpStatus.SC_OK) {
-                return RemoteOperationResult(false, getMethod)   // guard clause — fail fast
-            }
-            val response = ocsJson.decodeFromString<OcsResponse<List<HoldLabelInfo>>>(
-                getMethod.getResponseBodyAsString()
-            )
-            val data = response.ocs.data
-            RemoteOperationResult<List<HoldLabelInfo>>(true, getMethod).apply { resultData = data }
-        } catch (e: Exception) {
-            failure(e)
-        } finally {
-            getMethod.releaseConnection()
-        }
-    }
+class GetTeamFolderRemoteOperation(
+    private val teamId: String
+) : OcsKotlinRemoteOperation<TeamFolder>() {
+    override fun createMethod(baseUrl: String) =
+        GetMethod(baseUrl + ENDPOINT + SEPARATOR + teamId + FOLDER + JSON_FORMAT, true)
 
-    @Suppress("DEPRECATION")
-    private fun failure(e: Exception): RemoteOperationResult<List<HoldLabelInfo>> =
-        RemoteOperationResult<List<HoldLabelInfo>>(e).also {
-            Log_OC.e(TAG, "Get available hold labels failed: " + it.logMessage, it.exception)
-        }
+    override fun parse(body: String) = decode(body, TeamFolder.serializer())
 
     companion object {
-        private val TAG = GetAvailableHoldLabelsRemoteOperation::class.java.simpleName
-        private const val ENDPOINT = "/ocs/v2.php/apps/governance/v1/labels/"
-        private const val HOLD_AVAILABLE = "/hold/available"
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/teams"
+        private const val FOLDER = "/folder"
     }
 }
 ```
 
-Why it is written this way — keep all of it:
+Variations:
+
+- **List response:** `decode(body, ListSerializer(TeamMember.serializer()))`.
+- **Wrapped response** (`{ "resources": [...] }`): decode the internal wrapper and unwrap it —
+  `decode(body, TeamResourcesResponse.serializer()).resources`.
+- **Request body:**
+
+  ```kotlin
+  override fun createMethod(baseUrl: String) =
+      PostMethod(
+          baseUrl + ENDPOINT + JSON_FORMAT,
+          true,
+          jsonBody(CreateTeamRequest(name, createTeamFolder), CreateTeamRequest.serializer())
+      )
+  ```
+
+- **No useful response data:** type the operation `OcsKotlinRemoteOperation<Void>` and
+  `override fun parse(body: String): Void? = null`. Don't decode a loosely shaped response just to
+  throw it away.
+
+Do **not** override `run()` and do not copy the base class body into an operation. If an endpoint needs
+something the base class cannot express (e.g. a different success status), extend the base class in
+one place so every operation benefits — do not fork the call logic.
+
+Why the base class is written the way it is (keep this when changing it):
 
 - **Fail fast, read top to bottom.** A guard clause returns early on non-OK status. No nested
   `if/else`, no `else` branch.
-- **Return count ≤ 2.** The structure has exactly two `return` keywords: the guard `return` and the
-  outer `return try`. The success value and `failure(e)` are *expressions* of the `try`/`catch`, not
-  extra returns. Do not add a third `return` (detekt `ReturnCount: max: 2`).
-- **One catch.** Catch `Exception` once and delegate to `failure(...)`; do not stack
-  `catch (IOException)` + `catch (Exception)`. Add `@Suppress("TooGenericExceptionCaught")` on `run()`.
-  Split into a specific catch only when an exception genuinely needs different handling.
+- **Return count ≤ 2.** Exactly two `return` keywords: the guard `return` and the outer `return try`
+  (detekt `ReturnCount: max: 2`).
+- **One catch.** `catch (e: Exception)` once, delegated to `failure(e)`, with
+  `@Suppress("TooGenericExceptionCaught")` on `run()`.
 - **`finally { method.releaseConnection() }`** always runs, including on the early `return`.
-- **Property access**, not setters: `apply { resultData = data }` — `RemoteOperationResult` exposes
-  `resultData` as a Kotlin property. Use a `set…()` method only when Java interop / an existing API
-  contract forces it.
-- **`failure(...)` helper** carries `@Suppress("DEPRECATION")` because `RemoteOperationResult.logMessage`
-  is a deprecated Java accessor. Suppress at the usage only — never globally.
+- **Property access**, not setters: `apply { resultData = data }`.
+- **`failure(...)`** carries `@Suppress("DEPRECATION")` because `RemoteOperationResult.logMessage` is a
+  deprecated Java accessor. Suppress at the usage only — never globally.
 
 ## Constants — no hardcoded strings
 
 - Path separators: reuse the shared `com.owncloud.android.lib.ocs.SEPARATOR` (`"/"`). Never inline `"/"`.
 - Endpoint base paths and per-endpoint path segments: `private const val` in the operation's
-  `companion object` (`ENDPOINT`, `HOLD_AVAILABLE`, …).
-- The same applies to parameter keys, headers, and repeated log/event strings.
+  `companion object` (`ENDPOINT`, `FOLDER`, `MEMBERS`, …). `JSON_FORMAT` is inherited.
+- The same applies to parameter keys, headers, and repeated strings.
+- Enum wire values that are numbers (detekt `MagicNumber` does not ignore enums): declare them as
+  file-level `private const val`s and pass those to the enum entries (see `TeamMemberType`).
 
-## Class design
+## Class design and comments
 
-Class names describe responsibility (`GetAvailableHoldLabelsRemoteOperation`). **Do not add class-level
-KDoc that just restates the name.** Comment only non-obvious business logic, deliberate decisions, or
-external limitations.
+Class names describe responsibility (`GetTeamFolderRemoteOperation`). **Do not add comments or KDoc**
+to new code — names, types and small functions carry the meaning. Explain non-obvious server behaviour
+(e.g. "fails with 404 when no team folder exists") to the human in your summary, not in the source.
 
 ## Testing
 
-### Unit tests
-
-Small, isolated tests with no live server. Add them beside the existing ones in
-`library/src/test/java/com/nextcloud/android/lib/resources/<feature>/`, mirroring the governance
-parsing tests — feed a sample OCS JSON string through `ocsJson.decodeFromString<OcsResponse<…>>(json)`
-and assert the decoded fields.
-
-```bash
-./gradlew :library:testDebugUnitTest --tests "com.nextcloud.android.lib.resources.<feature>.*"
-```
-
-### Integration / end-to-end tests
-
-Also add an integration test that makes the actual API call**. Add an instrumented test under
-`library/src/androidTest/java/com/nextcloud/android/lib/resources/<feature>/` that runs the operation
-against a live Nextcloud server and asserts the `RemoteOperationResult` (`isSuccess`, `resultData`,
-error codes). Mirror the existing `*IT` tests for server setup and teardown.
+Endpoints are verified with **integration tests only**. Do **not** add JSON-parsing unit tests for
+operations or models.
+
+- One `*IT` class per operation, named after it (`GetTeamFolderRemoteOperationIT`), in the **same
+  package layout** under `library/src/androidTest/java/…/resources/<feature>/<verb>/<subfeature>/`.
+- Extend `AbstractIT` and run the operation against the live server with `nextcloudClient`; assert
+  `isSuccess`, the relevant `resultData` fields and, for expected failures, `httpCode`.
+- Each test creates the data it needs through the library's own operations (e.g.
+  `CreateTeamRemoteOperation` before `GetTeamMembersRemoteOperation`); use unique names
+  (`"Team " + System.currentTimeMillis()`).
+- Gate on server version with `testOnlyOnServer(NextcloudVersion.nextcloud_XX)` using an existing
+  constant.
+- `client` / `nextcloudClient` are the **non-admin** `test` user on CI; `client2` is admin. Endpoints
+  that need admin must use `client2`.
+- The CI server only has the apps installed by `.github/workflows/configNC.sh`. If a test needs an app
+  that is not there, tell the human — don't edit the workflow as part of the endpoint task.
 
 ## Build & verify
 
 CI runs three checks in parallel — **`detekt`, `spotlessKotlinCheck`, and `lint`** (see
-`.github/workflows/check.yml`). Run the same ones locally, plus compile and tests, before finishing.
-All must pass.
+`.github/workflows/check.yml`). Compile main and test sources while working; run the static checks
+**once, at the end**, after the human has reviewed the result and agreed — not after every iteration.
 
 ```bash
-./gradlew :library:compileDebugKotlin                                   # compiles
-./gradlew :library:testDebugUnitTest --tests "com.<pkg>.*"             # unit tests for your package
-./gradlew :library:detekt                                              # static analysis (see thresholds below)
-./gradlew :library:spotlessKotlinCheck                                 # ktlint formatting
-./gradlew :library:lint                                                # Android lint
+./gradlew :library:compileDebugKotlin                 # main sources
+./gradlew :library:compileDebugAndroidTestKotlin      # integration tests
+./gradlew :library:detekt                             # static analysis (see thresholds below)
+./gradlew :library:spotlessKotlinCheck                # ktlint formatting
+./gradlew :library:lint                               # Android lint
 ```
 
 - **detekt** config: `library/detekt.yml`. The rules that bite endpoint code:
-  - `ReturnCount: max: 2` — a `run()` may contain at most **two** `return` keywords.
-  - `TooGenericExceptionCaught: active` — catching `Exception` requires `@Suppress("TooGenericExceptionCaught")`.
-  - `ThrowsCount: max: 2`.
+  - `ReturnCount: max: 2`, `TooGenericExceptionCaught: active`, `ThrowsCount: max: 2` — handled by
+    `OcsKotlinRemoteOperation`; another reason not to hand-write `run()`.
+  - `MagicNumber` (enums are not ignored), `LongParameterList` (6), `TooManyFunctions` (15).
 - **Line length: 120** (`.editorconfig`). Import ordering is disabled — do not reorder imports to "fix" lint.
-- **Formatting** is ktlint via spotless. `:library:spotlessKotlinCheck` may fail at *configuration*
-  time locally (a spotbugs/AGP incompatibility unrelated to your code); it still runs in CI, so
-  verify formatting by hand against the 120-char limit and the patterns above when it can't run.
+- **Formatting** is ktlint via spotless. `:library:spotlessKotlinCheck` runs locally and must pass
+  before you finish, exactly as in CI.
 
 ## Nextcloud Contribution Policy
 
@@ -267,33 +306,34 @@ Follow the
 
 - Only commit or push **when asked**. If you are on the default branch, create a branch first.
 - Sign commits (`git commit -s`) and follow Conventional Commits v1.0.0 (e.g.
-  `feat(governance): add hold-label endpoint`).
+  `feat(teams): add team folder endpoint`).
 - Reference the relevant issue in the PR body (e.g. "Closes #123").
 
 ## Definition of done
 
-- [ ] No Gson introduced; all wire models `@Serializable`, decoded via `ocsJson` + `OcsResponse<T>`.
+- [ ] Only the calls the client flow needs; each one verified against the server controller.
+- [ ] Operations extend `OcsKotlinRemoteOperation<T>`; no hand-written `run()`.
+- [ ] Layout is `<feature>/<verb>/<subfeature>/`; each model in the narrowest package that uses it,
+      shared ones in `<feature>/model/`.
+- [ ] No Gson; all wire models `@Serializable`; request classes `internal` with no default values.
 - [ ] No new Java classes.
-- [ ] Models/enums under `<feature>.model`; reusable types in `com.owncloud.android.lib.ocs`.
-- [ ] `run()` is a guard-clause + single `return try/catch/finally`; ≤ 2 returns; no nested if/else.
-- [ ] Exactly one `catch (e: Exception)` → `failure(e)`, with `@Suppress("TooGenericExceptionCaught")`.
 - [ ] No hardcoded `"/"` or endpoint strings; constants used.
-- [ ] `resultData = data` (property), not a setter, unless interop demands otherwise.
-- [ ] No name-restating class comments.
+- [ ] No comments or KDoc in new code; license header with your own name.
 - [ ] Lines ≤ 120.
-- [ ] Unit tests **and** an integration test (`*IT`) added.
-- [ ] `compileDebugKotlin`, `testDebugUnitTest`, `detekt`, `spotlessKotlinCheck`, and `lint` all pass.
+- [ ] One `*IT` per operation, mirroring the package layout; no parsing unit tests.
+- [ ] No changes to workflows, `NextcloudVersion` or other shared files unless the human asked.
+- [ ] Compiles (`compileDebugKotlin`, `compileDebugAndroidTestKotlin`); `detekt`,
+      `spotlessKotlinCheck` and `lint` run once at the end and pass.
 - [ ] Diff is minimal and focused — no drive-by changes.
 
 ## Workflow
 
-1. Open the closest existing endpoint in `resources/governance/` and mirror it.
-2. Add request/response/model/enum classes under `<feature>.model`.
-3. Add endpoint path constants to the companion object.
-4. Implement the operation using the template above.
-5. Add unit tests next to the existing governance parsing tests
-   (`library/src/test/java/com/nextcloud/android/lib/resources/<feature>/`).
-6. Add an integration test (`*IT`) under
-   `library/src/androidTest/java/com/nextcloud/android/lib/resources/<feature>/`.
-7. Run the CI checks: compile + tests + `detekt` + `spotlessKotlinCheck` + `lint`.
-8. Review the diff; remove anything unrelated.
+1. Write down the client flow and map each step to one server call (see [Scope](#scope-build-only-what-the-flow-needs)).
+2. Read the server controller for each call: route, verb, body, response shape.
+3. Decide the package of every model: one user → `<verb>/<subfeature>/model/`, several → `<feature>/model/`.
+4. Add the models (`@Serializable`; request/wrapper classes `internal`).
+5. Add each operation on top of `OcsKotlinRemoteOperation<T>`: `createMethod`, `parse`, companion constants.
+6. Add one `*IT` per operation in the mirrored `androidTest` package.
+7. Compile main + androidTest sources; present the result to the human for review.
+8. After review, run `detekt`, `spotlessKotlinCheck` and `lint` once; fix what they report.
+9. Review the diff; remove anything unrelated.
diff --git a/CLAUDE.md b/CLAUDE.md
index 739c15a07f..32741d9df0 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -12,22 +12,24 @@ APIs) consumed by the Nextcloud Android app. Mixed Java + Kotlin; new code is Ko
 **[AGENTS.md](AGENTS.md) is the source of truth for adding or changing network endpoints** — package
 layout, the `RemoteOperation` template, error handling, serialization, constants, and the detekt
 thresholds that gate CI. Follow it for any endpoint work. The canonical reference implementation is
-`library/src/main/java/com/nextcloud/android/lib/resources/governance/`.
+`library/src/main/java/com/nextcloud/android/lib/resources/teams/`, built on the base class
+`com.nextcloud.operations.OcsKotlinRemoteOperation`. Use the `add-remote-endpoint` skill for new endpoints.
 
 ## Where things live
 
-- Remote operations: `library/src/main/java/com/nextcloud/android/lib/resources/<feature>/`
-- Wire models/enums: `…/resources/<feature>/model/`
-- Shared OCS types: `com.owncloud.android.lib.ocs` — `OcsResponse<T>` / `Ocs<T>` envelope,
+- Remote operations: `library/src/main/java/com/nextcloud/android/lib/resources/<feature>/<verb>/<subfeature>/`
+- Wire models/enums: `…/<verb>/<subfeature>/model/` when only that operation uses them,
+  `…/<feature>/model/` when shared
+- Shared OCS types: `com.owncloud.android.lib.ocs` — `OcsKotlinResponse<T>` envelope,
   `ocsJson` (strict `Json`), `SEPARATOR` (`"/"`)
-- Unit tests: `library/src/test/java/…` &nbsp;·&nbsp; instrumented tests: `library/src/androidTest/java/…`
+- Integration tests (one `*IT` per operation, mirrored packages): `library/src/androidTest/java/…`
 
 ## Commands
 
 ```bash
 ./gradlew :library:compileDebugKotlin
-./gradlew :library:testDebugUnitTest --tests "com.nextcloud.android.lib.resources.governance.*"
-./gradlew :library:detekt
+./gradlew :library:compileDebugAndroidTestKotlin
+./gradlew :library:detekt          # with spotlessKotlinCheck + lint: once, at the end, after review
 ```
 
 ## Gotchas
@@ -35,11 +37,11 @@ thresholds that gate CI. Follow it for any endpoint work. The canonical referenc
 - **kotlinx.serialization, not Gson.** The compiler plugin is applied in `library/build.gradle`; the
   `kotlinx-serialization-json` runtime dependency alone is not enough — both are required.
 - **detekt (`library/detekt.yml`) is strict on operations:** `ReturnCount: max 2`,
-  `TooGenericExceptionCaught` active (needs `@Suppress` on `run()`), `ThrowsCount: max 2`. AGENTS.md
-  shows the two-return / single-catch pattern that satisfies these.
+  `TooGenericExceptionCaught` active (needs `@Suppress` on `run()`), `ThrowsCount: max 2`.
+  `OcsKotlinRemoteOperation` already satisfies these — never hand-write `run()` in an operation.
 - **Line length 120** (`.editorconfig`); import ordering is disabled — don't reorder imports.
-- **`:library:spotlessKotlinCheck` currently fails at configuration time** (a spotbugs/AGP issue,
-  not your code). Verify Kotlin formatting by hand against the 120-char limit and the AGENTS.md patterns.
+- **`:library:spotlessKotlinCheck`** (ktlint) runs locally; run it with detekt and lint at the end and
+  make sure it passes, as CI does.
 - **`RemoteOperationResult.logMessage`** is a deprecated Java accessor — suppress at the call site
   only (`@Suppress("DEPRECATION")` on the `failure(...)` helper), never globally.
 
@@ -47,4 +49,6 @@ thresholds that gate CI. Follow it for any endpoint work. The canonical referenc
 
 - Kotlin only for new classes; don't add Java classes. Java 17 is available for editing existing Java.
 - Keep diffs minimal and focused; don't reformat or refactor unrelated code.
+- Implement only the calls the client flow needs; don't touch workflows or `NextcloudVersion` as a side effect.
+- No comments or KDoc in new code; no JSON-parsing unit tests (integration tests only).
 - Only commit or push when asked.
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/TeamTestHelper.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/TeamTestHelper.kt
new file mode 100644
index 0000000000..9a2dc4316d
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/TeamTestHelper.kt
@@ -0,0 +1,24 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams
+
+import com.nextcloud.android.lib.resources.teams.model.Team
+import com.nextcloud.android.lib.resources.teams.post.team.CreateTeamRemoteOperation
+import com.nextcloud.common.NextcloudClient
+import org.junit.Assert.assertTrue
+import kotlin.uuid.Uuid
+
+private const val TEAM_NAME_PREFIX = "Team "
+
+fun uniqueTeamName(): String = TEAM_NAME_PREFIX + Uuid.random()
+
+fun NextcloudClient.createTestTeam(createTeamFolder: Boolean = false): Team {
+    val result = CreateTeamRemoteOperation(uniqueTeamName(), createTeamFolder).execute(this)
+    assertTrue(result.isSuccess)
+    return result.resultData
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperationIT.kt
new file mode 100644
index 0000000000..3ea4e7c35a
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperationIT.kt
@@ -0,0 +1,45 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.folder
+
+import com.nextcloud.android.lib.resources.teams.createTestTeam
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.apache.commons.httpclient.HttpStatus
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class GetTeamFolderRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun getTeamFolder() {
+        val team = nextcloudClient.createTestTeam(createTeamFolder = true)
+
+        val result = GetTeamFolderRemoteOperation(team.id).execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        assertTrue(result.resultData.mountPoint.isNotEmpty())
+    }
+
+    @Test
+    fun getTeamFolderWithoutFolder() {
+        val team = nextcloudClient.createTestTeam()
+
+        val result = GetTeamFolderRemoteOperation(team.id).execute(nextcloudClient)
+
+        assertFalse(result.isSuccess)
+        assertEquals(HttpStatus.SC_NOT_FOUND, result.httpCode)
+    }
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperationIT.kt
new file mode 100644
index 0000000000..06ce8d431c
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperationIT.kt
@@ -0,0 +1,38 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.members
+
+import com.nextcloud.android.lib.resources.teams.createTestTeam
+import com.nextcloud.android.lib.resources.teams.model.TeamMemberType
+import com.nextcloud.android.lib.resources.teams.model.TeamRole
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class GetTeamMembersRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun getMembers() {
+        val team = nextcloudClient.createTestTeam()
+
+        val result = GetTeamMembersRemoteOperation(team.id).execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        assertTrue(
+            result.resultData.any {
+                it.userId == nextcloudClient.userId && it.role == TeamRole.OWNER && it.type == TeamMemberType.USER
+            }
+        )
+    }
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperationIT.kt
new file mode 100644
index 0000000000..4bda580863
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperationIT.kt
@@ -0,0 +1,33 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.resources
+
+import com.nextcloud.android.lib.resources.teams.createTestTeam
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class GetTeamResourcesRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun getResources() {
+        val team = nextcloudClient.createTestTeam()
+
+        val result = GetTeamResourcesRemoteOperation(team.id).execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        assertNotNull(result.resultData)
+    }
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperationIT.kt
new file mode 100644
index 0000000000..d0bcf80e84
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperationIT.kt
@@ -0,0 +1,39 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.team
+
+import com.nextcloud.android.lib.resources.teams.createTestTeam
+import com.nextcloud.android.lib.resources.teams.model.TeamRole
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class GetTeamsRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun getTeams() {
+        val created = nextcloudClient.createTestTeam()
+
+        val result = GetTeamsRemoteOperation().execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        val team = result.resultData.firstOrNull { it.id == created.id }
+        assertNotNull(team)
+        assertTrue(team!!.isMember)
+        assertEquals(TeamRole.OWNER, team.role)
+        assertEquals(created.url, team.url)
+    }
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperationIT.kt
new file mode 100644
index 0000000000..b33e562805
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperationIT.kt
@@ -0,0 +1,41 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.members
+
+import com.nextcloud.android.lib.resources.teams.createTestTeam
+import com.nextcloud.android.lib.resources.teams.get.members.GetTeamMembersRemoteOperation
+import com.nextcloud.android.lib.resources.teams.model.TeamMemberType
+import com.nextcloud.android.lib.resources.teams.post.members.model.NewTeamMember
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class AddTeamMembersRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun addMembers() {
+        val team = nextcloudClient.createTestTeam()
+        val members = listOf(NewTeamMember(MEMBER_USER_ID, TeamMemberType.USER))
+
+        val result = AddTeamMembersRemoteOperation(team.id, members).execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        val teamMembers = GetTeamMembersRemoteOperation(team.id).execute(nextcloudClient)
+        assertTrue(teamMembers.resultData.any { it.userId == MEMBER_USER_ID })
+    }
+
+    companion object {
+        private const val MEMBER_USER_ID = "user1"
+    }
+}
diff --git a/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperationIT.kt b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperationIT.kt
new file mode 100644
index 0000000000..d044b013b1
--- /dev/null
+++ b/library/src/androidTest/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperationIT.kt
@@ -0,0 +1,38 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.team
+
+import com.nextcloud.android.lib.resources.teams.model.TeamRole
+import com.nextcloud.android.lib.resources.teams.uniqueTeamName
+import com.owncloud.android.AbstractIT
+import com.owncloud.android.lib.resources.status.NextcloudVersion
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class CreateTeamRemoteOperationIT : AbstractIT() {
+    @Before
+    fun before() {
+        testOnlyOnServer(NextcloudVersion.nextcloud_34)
+    }
+
+    @Test
+    fun createTeam() {
+        val name = uniqueTeamName()
+
+        val result = CreateTeamRemoteOperation(name, false).execute(nextcloudClient)
+
+        assertTrue(result.isSuccess)
+        val team = result.resultData
+        assertTrue(team.id.isNotEmpty())
+        assertEquals(name, team.displayName)
+        assertTrue(team.url.isNotEmpty())
+        assertEquals(TeamRole.OWNER, team.role)
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperation.kt
new file mode 100644
index 0000000000..00b0f3ec8b
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/GetTeamFolderRemoteOperation.kt
@@ -0,0 +1,27 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.folder
+
+import com.nextcloud.android.lib.resources.teams.get.folder.model.TeamFolder
+import com.nextcloud.operations.GetMethod
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import com.owncloud.android.lib.ocs.SEPARATOR
+
+class GetTeamFolderRemoteOperation(
+    private val teamId: String
+) : OcsKotlinRemoteOperation<TeamFolder>() {
+    override fun createMethod(baseUrl: String) =
+        GetMethod(baseUrl + ENDPOINT + SEPARATOR + teamId + FOLDER + JSON_FORMAT, true)
+
+    override fun parse(body: String) = decode(body, TeamFolder.serializer())
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/teams"
+        private const val FOLDER = "/folder"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/model/TeamFolder.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/model/TeamFolder.kt
new file mode 100644
index 0000000000..bbd7ca600d
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/folder/model/TeamFolder.kt
@@ -0,0 +1,17 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.folder.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class TeamFolder(
+    val id: Long,
+    val mountPoint: String,
+    val quota: Long? = null
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperation.kt
new file mode 100644
index 0000000000..a4306bfacd
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/members/GetTeamMembersRemoteOperation.kt
@@ -0,0 +1,28 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.members
+
+import com.nextcloud.android.lib.resources.teams.model.TeamMember
+import com.nextcloud.operations.GetMethod
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import com.owncloud.android.lib.ocs.SEPARATOR
+import kotlinx.serialization.builtins.ListSerializer
+
+class GetTeamMembersRemoteOperation(
+    private val teamId: String
+) : OcsKotlinRemoteOperation<List<TeamMember>>() {
+    override fun createMethod(baseUrl: String) =
+        GetMethod(baseUrl + ENDPOINT + SEPARATOR + teamId + MEMBERS + JSON_FORMAT, true)
+
+    override fun parse(body: String) = decode(body, ListSerializer(TeamMember.serializer()))
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/circles"
+        private const val MEMBERS = "/members"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperation.kt
new file mode 100644
index 0000000000..81181a0516
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/GetTeamResourcesRemoteOperation.kt
@@ -0,0 +1,28 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.resources
+
+import com.nextcloud.android.lib.resources.teams.get.resources.model.TeamResource
+import com.nextcloud.android.lib.resources.teams.get.resources.model.TeamResourcesResponse
+import com.nextcloud.operations.GetMethod
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import com.owncloud.android.lib.ocs.SEPARATOR
+
+class GetTeamResourcesRemoteOperation(
+    private val teamId: String
+) : OcsKotlinRemoteOperation<List<TeamResource>>() {
+    override fun createMethod(baseUrl: String) =
+        GetMethod(baseUrl + ENDPOINT + SEPARATOR + teamId + RESOURCES + JSON_FORMAT, true)
+
+    override fun parse(body: String) = decode(body, TeamResourcesResponse.serializer()).resources
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/teams"
+        private const val RESOURCES = "/resources"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResource.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResource.kt
new file mode 100644
index 0000000000..d17c1323e5
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResource.kt
@@ -0,0 +1,21 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.resources.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class TeamResource(
+    val id: String,
+    val label: String,
+    val url: String,
+    val iconSvg: String? = null,
+    val iconURL: String? = null,
+    val iconEmoji: String? = null,
+    val provider: TeamResourceProvider
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourceProvider.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourceProvider.kt
new file mode 100644
index 0000000000..9fab90b55d
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourceProvider.kt
@@ -0,0 +1,17 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.resources.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class TeamResourceProvider(
+    val id: String,
+    val name: String,
+    val icon: String? = null
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourcesResponse.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourcesResponse.kt
new file mode 100644
index 0000000000..555b31685c
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/resources/model/TeamResourcesResponse.kt
@@ -0,0 +1,15 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.resources.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class TeamResourcesResponse(
+    val resources: List<TeamResource>
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperation.kt
new file mode 100644
index 0000000000..9e418b6bfe
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/get/team/GetTeamsRemoteOperation.kt
@@ -0,0 +1,23 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.get.team
+
+import com.nextcloud.android.lib.resources.teams.model.Team
+import com.nextcloud.operations.GetMethod
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import kotlinx.serialization.builtins.ListSerializer
+
+class GetTeamsRemoteOperation : OcsKotlinRemoteOperation<List<Team>>() {
+    override fun createMethod(baseUrl: String) = GetMethod(baseUrl + ENDPOINT + JSON_FORMAT, true)
+
+    override fun parse(body: String) = decode(body, ListSerializer(Team.serializer()))
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/circles"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/Team.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/Team.kt
new file mode 100644
index 0000000000..8383ab914f
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/Team.kt
@@ -0,0 +1,30 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Team(
+    val id: String,
+    val name: String,
+    val displayName: String,
+    val description: String = "",
+    val population: Int = 0,
+    val url: String = "",
+    val initiator: TeamMember? = null
+) {
+    val isMember: Boolean
+        get() = initiator != null && !isPendingRequest
+
+    val isPendingRequest: Boolean
+        get() = initiator?.isPendingRequest == true
+
+    val role: TeamRole?
+        get() = initiator?.takeIf { isMember }?.role
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMember.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMember.kt
new file mode 100644
index 0000000000..9d8e9b2321
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMember.kt
@@ -0,0 +1,33 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class TeamMember(
+    val singleId: String,
+    val userId: String? = null,
+    val displayName: String = "",
+    val userType: Int = 0,
+    val level: Int = 0,
+    val status: String = ""
+) {
+    val role: TeamRole
+        get() = TeamRole.fromLevel(level)
+
+    val type: TeamMemberType?
+        get() = TeamMemberType.fromValue(userType)
+
+    val isPendingRequest: Boolean
+        get() = status == STATUS_REQUESTING
+
+    companion object {
+        const val STATUS_REQUESTING = "Requesting"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMemberType.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMemberType.kt
new file mode 100644
index 0000000000..2d38068fc1
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamMemberType.kt
@@ -0,0 +1,39 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.model
+
+import com.owncloud.android.lib.resources.shares.ShareType
+
+private const val TYPE_USER = 1
+private const val TYPE_GROUP = 2
+private const val TYPE_MAIL = 4
+private const val TYPE_CONTACT = 8
+private const val TYPE_CIRCLE = 16
+
+enum class TeamMemberType(
+    val value: Int
+) {
+    USER(TYPE_USER),
+    GROUP(TYPE_GROUP),
+    MAIL(TYPE_MAIL),
+    CONTACT(TYPE_CONTACT),
+    CIRCLE(TYPE_CIRCLE);
+
+    companion object {
+        fun fromValue(value: Int): TeamMemberType? = entries.firstOrNull { it.value == value }
+
+        fun fromShareType(shareType: ShareType): TeamMemberType? =
+            when (shareType) {
+                ShareType.USER, ShareType.FEDERATED -> USER
+                ShareType.GROUP -> GROUP
+                ShareType.EMAIL -> MAIL
+                ShareType.CIRCLE -> CIRCLE
+                else -> null
+            }
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamRole.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamRole.kt
new file mode 100644
index 0000000000..7c9c6bb6af
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/model/TeamRole.kt
@@ -0,0 +1,29 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.model
+
+private const val LEVEL_MODERATOR = 4
+private const val LEVEL_ADMIN = 8
+private const val LEVEL_OWNER = 9
+
+enum class TeamRole {
+    OWNER,
+    ADMIN,
+    MODERATOR,
+    MEMBER;
+
+    companion object {
+        fun fromLevel(level: Int): TeamRole =
+            when {
+                level >= LEVEL_OWNER -> OWNER
+                level >= LEVEL_ADMIN -> ADMIN
+                level >= LEVEL_MODERATOR -> MODERATOR
+                else -> MEMBER
+            }
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperation.kt
new file mode 100644
index 0000000000..a47d2db439
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/AddTeamMembersRemoteOperation.kt
@@ -0,0 +1,37 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.members
+
+import com.nextcloud.android.lib.resources.teams.post.members.model.AddTeamMemberRequest
+import com.nextcloud.android.lib.resources.teams.post.members.model.AddTeamMembersRequest
+import com.nextcloud.android.lib.resources.teams.post.members.model.NewTeamMember
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import com.nextcloud.operations.PostMethod
+import com.owncloud.android.lib.ocs.SEPARATOR
+
+class AddTeamMembersRemoteOperation(
+    private val teamId: String,
+    private val members: List<NewTeamMember>
+) : OcsKotlinRemoteOperation<Void>() {
+    override fun createMethod(baseUrl: String) =
+        PostMethod(
+            baseUrl + ENDPOINT + SEPARATOR + teamId + MEMBERS_MULTI + JSON_FORMAT,
+            true,
+            jsonBody(
+                AddTeamMembersRequest(members.map { AddTeamMemberRequest(it.id, it.type.value) }),
+                AddTeamMembersRequest.serializer()
+            )
+        )
+
+    override fun parse(body: String): Void? = null
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/circles"
+        private const val MEMBERS_MULTI = "/members/multi"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMemberRequest.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMemberRequest.kt
new file mode 100644
index 0000000000..9893226154
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMemberRequest.kt
@@ -0,0 +1,16 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.members.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class AddTeamMemberRequest(
+    val id: String,
+    val type: Int
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMembersRequest.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMembersRequest.kt
new file mode 100644
index 0000000000..327894f426
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/AddTeamMembersRequest.kt
@@ -0,0 +1,15 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.members.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class AddTeamMembersRequest(
+    val members: List<AddTeamMemberRequest>
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/NewTeamMember.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/NewTeamMember.kt
new file mode 100644
index 0000000000..8103c52440
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/members/model/NewTeamMember.kt
@@ -0,0 +1,15 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.members.model
+
+import com.nextcloud.android.lib.resources.teams.model.TeamMemberType
+
+data class NewTeamMember(
+    val id: String,
+    val type: TeamMemberType
+)
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperation.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperation.kt
new file mode 100644
index 0000000000..0de498dafc
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/CreateTeamRemoteOperation.kt
@@ -0,0 +1,31 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.team
+
+import com.nextcloud.android.lib.resources.teams.model.Team
+import com.nextcloud.android.lib.resources.teams.post.team.model.CreateTeamRequest
+import com.nextcloud.operations.OcsKotlinRemoteOperation
+import com.nextcloud.operations.PostMethod
+
+class CreateTeamRemoteOperation(
+    private val name: String,
+    private val createTeamFolder: Boolean = true
+) : OcsKotlinRemoteOperation<Team>() {
+    override fun createMethod(baseUrl: String) =
+        PostMethod(
+            baseUrl + ENDPOINT + JSON_FORMAT,
+            true,
+            jsonBody(CreateTeamRequest(name, createTeamFolder), CreateTeamRequest.serializer())
+        )
+
+    override fun parse(body: String) = decode(body, Team.serializer())
+
+    companion object {
+        private const val ENDPOINT = "/ocs/v2.php/apps/circles/circles"
+    }
+}
diff --git a/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/model/CreateTeamRequest.kt b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/model/CreateTeamRequest.kt
new file mode 100644
index 0000000000..8d2de57309
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/android/lib/resources/teams/post/team/model/CreateTeamRequest.kt
@@ -0,0 +1,16 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.android.lib.resources.teams.post.team.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class CreateTeamRequest(
+    val name: String,
+    val createTeamFolder: Boolean
+)
diff --git a/library/src/main/java/com/nextcloud/common/OkHttpMethodBase.kt b/library/src/main/java/com/nextcloud/common/OkHttpMethodBase.kt
index 5ea1def226..38354aaefb 100644
--- a/library/src/main/java/com/nextcloud/common/OkHttpMethodBase.kt
+++ b/library/src/main/java/com/nextcloud/common/OkHttpMethodBase.kt
@@ -41,6 +41,9 @@ abstract class OkHttpMethodBase(
     private val requestBuilder: Request.Builder = Request.Builder()
     private var request: Request? = null
 
+    var networkException: IOException? = null
+        private set
+
     @Throws(IllegalStateException::class)
     private fun buildQueryParameter(): HttpUrl {
         val httpBuilder =
@@ -122,6 +125,7 @@ abstract class OkHttpMethodBase(
         try {
             response = nextcloudClient.client.newCall(request).execute()
         } catch (ex: IOException) {
+            networkException = ex
             return UNKNOWN_STATUS_CODE
         }
 
diff --git a/library/src/main/java/com/nextcloud/operations/OcsKotlinRemoteOperation.kt b/library/src/main/java/com/nextcloud/operations/OcsKotlinRemoteOperation.kt
new file mode 100644
index 0000000000..a6a43355fe
--- /dev/null
+++ b/library/src/main/java/com/nextcloud/operations/OcsKotlinRemoteOperation.kt
@@ -0,0 +1,69 @@
+/*
+ * Nextcloud Android Library
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+package com.nextcloud.operations
+
+import com.nextcloud.common.NextcloudClient
+import com.nextcloud.common.OkHttpMethodBase
+import com.owncloud.android.lib.common.operations.RemoteOperation
+import com.owncloud.android.lib.common.operations.RemoteOperationResult
+import com.owncloud.android.lib.common.utils.Log_OC
+import com.owncloud.android.lib.ocs.OcsKotlinResponse
+import com.owncloud.android.lib.ocs.ocsJson
+import kotlinx.serialization.KSerializer
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.apache.commons.httpclient.HttpStatus
+
+abstract class OcsKotlinRemoteOperation<T> : RemoteOperation<T>() {
+    protected abstract fun createMethod(baseUrl: String): OkHttpMethodBase
+
+    protected abstract fun parse(body: String): T?
+
+    @Suppress("TooGenericExceptionCaught")
+    override fun run(client: NextcloudClient): RemoteOperationResult<T> {
+        val method = createMethod(client.baseUri.toString())
+        return try {
+            val status = client.execute(method)
+            method.networkException?.let { throw it }
+            if (status != HttpStatus.SC_OK) {
+                Log_OC.e(tag, "Failed with status code: $status")
+                return RemoteOperationResult(false, method)
+            }
+            val data = parse(method.getResponseBodyAsString())
+            RemoteOperationResult<T>(true, method).apply { resultData = data }
+        } catch (e: Exception) {
+            failure(e)
+        } finally {
+            method.releaseConnection()
+        }
+    }
+
+    protected fun <R> decode(
+        body: String,
+        serializer: KSerializer<R>
+    ): R = ocsJson.decodeFromString(OcsKotlinResponse.serializer(serializer), body).ocs.data
+
+    protected fun <R> jsonBody(
+        value: R,
+        serializer: KSerializer<R>
+    ): RequestBody = ocsJson.encodeToString(serializer, value).toRequestBody(JSON_MEDIA_TYPE.toMediaTypeOrNull())
+
+    @Suppress("DEPRECATION")
+    private fun failure(e: Exception): RemoteOperationResult<T> =
+        RemoteOperationResult<T>(e).also {
+            Log_OC.e(tag, "Failed: " + it.logMessage, it.exception)
+        }
+
+    private val tag: String
+        get() = javaClass.simpleName
+
+    companion object {
+        private const val JSON_MEDIA_TYPE = "application/json"
+    }
+}