hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/api/pipelines.py

@@ -0,0 +1,1515 @@
+# this file is @generated
+"""Pipelines API."""
+
+from __future__ import annotations
+
+import builtins
+import functools
+import typing as t
+from datetime import datetime
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    CountRefRequest,
+    CreatePipelineRequestV2,
+    CreateRefRequest,
+    PipelineDetailResponse,
+    PipelineResponseData,
+    PipelinesPage,
+    PipelineStatusFilter,
+    Ref,
+    RefreshCredentialsSummary,
+    RefStatus,
+    RefStatusLiteral,
+    TestImapConnectionRequest,
+    TestImapConnectionResponse,
+    UpdatePipelineConfigRequest,
+    UpdatePipelineRequest,
+    UpdateRefRequest,
+)
+from ..serialization import UNSET, Unset, to_json_value
+from ._pages import (
+    AsyncPipelinesListPage,
+    PipelinesListPage,
+)
+from ._pagination import (
+    AsyncPaginator,
+    PagePaging,
+)
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+    serialize_query_params,
+)
+from .pipelines_runs import (
+    AsyncPipelinesRuns,
+    AsyncPipelinesRunsWithRawResponse,
+    PipelinesRuns,
+    PipelinesRunsWithRawResponse,
+)
+from .pipelines_stats_api import (
+    AsyncPipelinesStatsApi,
+    AsyncPipelinesStatsApiWithRawResponse,
+    PipelinesStatsApi,
+    PipelinesStatsApiWithRawResponse,
+)
+
+
+class AsyncPipelines(ApiBaseAsync):
+    """Pipelines API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncPipelinesWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncPipelinesWithRawResponse(self)
+
+    @functools.cached_property
+    def runs(self) -> AsyncPipelinesRuns:
+        """The runs API."""
+        return AsyncPipelinesRuns(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def stats(self) -> AsyncPipelinesStatsApi:
+        """The stats API."""
+        return AsyncPipelinesStatsApi(self._cfg, self._httpx_client)
+
+    def list(
+        self,
+        organization_id: UUID,
+        *,
+        page: int | None = None,
+        limit: int | None = None,
+        search: str | None = None,
+        status: PipelineStatusFilter | None = None,
+        harbor_id: UUID | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> AsyncPaginator[PipelineResponseData, AsyncPipelinesListPage]:
+        """`GET /api/v1/organizations/{organization_id}/pipelines`: the first page, iterate it for every item.
+
+        :param page: Zero-based page index. Absent or omitted defaults to the first page.
+        :param limit: Page size, clamped to `[1, 200]`. Absent defaults to 50.
+        :param search: Case-insensitive substring match on the pipeline name. Absent matches every name.
+        :param status: Filter by suspend state. Absent behaves like `all`.
+        :param harbor_id: Restrict to one harbor of this organization (exact match). Absent matches every pipeline in the org. The request is authorized against this harbor when it is given and against the whole organization when it is not, so a grant scoped to one harbor admits only a request that names that harbor."""
+
+        async def fetch(page_param: int | None) -> PipelinesPage:
+            response = await self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/organizations/{organization_id}/pipelines",
+                    path_params={
+                        "organization_id": encode_path_param(
+                            "organization_id", organization_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "page": page_param,
+                            "limit": limit,
+                            "search": search,
+                            "status": status,
+                            "harbor_id": harbor_id,
+                        },
+                    ),
+                    error_types={
+                        "default": _models.ApiErrorBody,
+                    },
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                    max_retries=max_retries,
+                )
+            )
+            return decode_response(response, PipelinesPage)
+
+        paging = PagePaging[PipelinesPage, PipelineResponseData](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return AsyncPaginator(
+            lambda: AsyncPipelinesListPage._first(fetch, page, paging)
+        )
+
+    async def test_imap_connection(
+        self,
+        organization_id: UUID,
+        *,
+        folder: str,
+        host: str,
+        port: int,
+        username: str,
+        ca_cert: str | None | Unset = UNSET,
+        password: str | None | Unset = UNSET,
+        password_secret_id: UUID | None | Unset = UNSET,
+        use_tls: bool | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> TestImapConnectionResponse:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/test-imap-connection`.
+
+        :param password: The mailbox password, as a literal.  Optional since #4237: a caller whose password already lives in the secret manager sends `password_secret_id` instead, and exactly one of the two is required. Nothing is persisted either way — this endpoint opens a session and closes it — but the literal form means the password travels in a request body, and a console that only ever holds a secret id can now avoid that.
+        :param password_secret_id: A `plaintext` Passe-Partout secret in **this** organization holding the password.  Deliberately a bare id and not a `{organization_id, secret_id}` pair: the organization is the route's, so this endpoint cannot express a read outside the caller's own tenant. The secret is still put through the admission gate ([`SecretUsage::PipelineImapProbePassword`]), so one member cannot dereference another's private secret by probing a mail server with it."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/test-imap-connection",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    TestImapConnectionRequest(
+                        ca_cert=ca_cert,
+                        folder=folder,
+                        host=host,
+                        password=password,
+                        password_secret_id=password_secret_id,
+                        port=port,
+                        use_tls=use_tls,
+                        username=username,
+                    ),
+                    TestImapConnectionRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, TestImapConnectionResponse)
+
+    async def retrieve(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PipelineDetailResponse:
+        """`GET /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PipelineDetailResponse)
+
+    async def delete(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`DELETE /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`."""
+        await self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def update(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        suspend: bool,
+        max_duration_minutes: int | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`PATCH /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`.
+
+        :param max_duration_minutes: Wall-clock budget for one run, in minutes (1..=1440), or `null` to hand the budget back to the schedule — three times its interval, clamped into 15 minutes ..= 6 hours.  Applied as stated rather than as a patch, like `suspend` beside it: this is the value the pipeline should end up with. An omitted field therefore means "automatic", which is what every pipeline had before the column existed, so a caller written against the older shape is unaffected.
+        :param suspend: When true the underlying CronJob is suspended (no new runs will be scheduled)."""
+        await self._request(
+            ApiRequest(
+                method="patch",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    UpdatePipelineRequest(
+                        max_duration_minutes=max_duration_minutes,
+                        suspend=suspend,
+                    ),
+                    UpdatePipelineRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def update_config(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        body: UpdatePipelineConfigRequest,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """Update a SharePoint or GDrive connector's settings - site/library/folder,
+        service-account/tenant credential, destination bucket/prefix, schedule -
+        without recreating the pipeline. See `UpdatePipelineConfigRequest`'s own
+        doc comment for what stays fixed (name, harbor, extraction) and why."""
+        await self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/config",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(body, UpdatePipelineConfigRequest),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def refresh_credentials(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> RefreshCredentialsSummary:
+        """Re-resolves S3 credentials for every S3 connection in the pipeline CRD and
+        patches the CRD `spec.pipelineConfig.raw`. Intended to be called after an
+        org has migrated off a legacy DataDock to the shared per-Org RGW (#2228) so
+        scheduled pipeline runs pick up the new credentials without operator
+        recreating the pipeline.
+
+        Returns:
+        - `200` with the per-connection backing sources on success
+        - `404` if neither the DB row nor the CRD for the pipeline exists
+        - `409` if the pipeline currently has a run in `Running` status — swapping
+           creds out from under a running task would corrupt the in-flight transfer
+        - `409` if the pipeline's CR runs outside its environment's namespace, where
+           no refresh can reach it; deleting the pipeline and creating it again can"""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refresh-credentials",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, RefreshCredentialsSummary)
+
+    async def count_pipeline_refs(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        status: RefStatus | None = None,
+        key: str | None = None,
+        locked: bool | None = None,
+        updated_at_before: datetime | None = None,
+        updated_at_after: datetime | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> str:
+        """`GET /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refs`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "status": status,
+                        "key": key,
+                        "locked": locked,
+                        "updated_at_before": updated_at_before,
+                        "updated_at_after": updated_at_after,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return response.text
+
+    async def resume(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/resume`."""
+        await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/resume",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def suspend(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/suspend`."""
+        await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/suspend",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def trigger(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/trigger`."""
+        await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/trigger",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    async def count_refs(
+        self,
+        *,
+        key: str | None | Unset = UNSET,
+        locked: bool | None | Unset = UNSET,
+        pipeline_id: UUID | None | Unset = UNSET,
+        status: RefStatus | RefStatusLiteral | None | Unset = UNSET,
+        updated_at_after: datetime | None | Unset = UNSET,
+        updated_at_before: datetime | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> str:
+        """`POST /api/v1/refs/count`."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/refs/count",
+                json_body=to_json_value(
+                    CountRefRequest(
+                        key=key,
+                        locked=locked,
+                        pipeline_id=pipeline_id,
+                        status=t.cast("RefStatus | None | Unset", status),
+                        updated_at_after=updated_at_after,
+                        updated_at_before=updated_at_before,
+                    ),
+                    CountRefRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return response.text
+
+    async def list_refs_list(
+        self,
+        *,
+        pipeline_id: UUID | None = None,
+        pipeline_checksum: str | None = None,
+        status: RefStatus | None = None,
+        key: str | None = None,
+        updated_at_before: datetime | None = None,
+        updated_at_after: datetime | None = None,
+        lock: bool | None = None,
+        locked_by: UUID | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> builtins.list[Ref]:
+        """`GET /api/v1/refs/list`.
+
+        :param lock: Whether to lock the references listed"""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/refs/list",
+                query_params=serialize_query_params(
+                    {
+                        "pipeline_id": pipeline_id,
+                        "pipeline_checksum": pipeline_checksum,
+                        "status": status,
+                        "key": key,
+                        "updated_at_before": updated_at_before,
+                        "updated_at_after": updated_at_after,
+                        "lock": lock,
+                        "locked_by": locked_by,
+                        "limit": limit,
+                        "offset": offset,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[Ref])
+
+    async def create_many_refs(
+        self,
+        body: builtins.list[CreateRefRequest],
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> builtins.list[Ref]:
+        """Registers refs in bulk, each with the status its entry names (absent means
+        `pending`).
+
+        Insert-only: a `(pipeline_id, pipeline_checksum, key)` that already exists keeps
+        the status it has and is NOT returned, so the reply is the rows actually created
+        and a `200 []` means every key was already there. This route cannot promote an
+        existing ref.
+
+        On the external router the batch must name exactly one pipeline and must not be
+        empty — that is the resource the request is authorized against — and a body that
+        breaks either rule answers 422 without reaching the authorization decision."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/refs/many",
+                json_body=to_json_value(body, list[CreateRefRequest]),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[Ref])
+
+    async def update_ref(
+        self,
+        key: str,
+        body: UpdateRefRequest,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> Ref:
+        """`PUT /api/v1/refs/{key}`."""
+        response = await self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/refs/{key}",
+                path_params={
+                    "key": key,
+                },
+                json_body=to_json_value(body, UpdateRefRequest),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, Ref)
+
+    async def create(
+        self,
+        body: CreatePipelineRequestV2,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PipelineResponseData:
+        """Creates a pipeline CRD using the new V2 API with discriminated union"""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v2/pipelines",
+                json_body=to_json_value(body, CreatePipelineRequestV2),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PipelineResponseData)
+
+
+class AsyncPipelinesWithRawResponse:
+    """The methods of :class:`AsyncPipelines`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncPipelines) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.test_imap_connection = async_to_raw_response_wrapper(
+            resource.test_imap_connection
+        )
+        self.retrieve = async_to_raw_response_wrapper(resource.retrieve)
+        self.delete = async_to_raw_response_wrapper(resource.delete)
+        self.update = async_to_raw_response_wrapper(resource.update)
+        self.update_config = async_to_raw_response_wrapper(resource.update_config)
+        self.refresh_credentials = async_to_raw_response_wrapper(
+            resource.refresh_credentials
+        )
+        self.count_pipeline_refs = async_to_raw_response_wrapper(
+            resource.count_pipeline_refs
+        )
+        self.resume = async_to_raw_response_wrapper(resource.resume)
+        self.suspend = async_to_raw_response_wrapper(resource.suspend)
+        self.trigger = async_to_raw_response_wrapper(resource.trigger)
+        self.count_refs = async_to_raw_response_wrapper(resource.count_refs)
+        self.list_refs_list = async_to_raw_response_wrapper(resource.list_refs_list)
+        self.create_many_refs = async_to_raw_response_wrapper(resource.create_many_refs)
+        self.update_ref = async_to_raw_response_wrapper(resource.update_ref)
+        self.create = async_to_raw_response_wrapper(resource.create)
+
+    @property
+    def runs(self) -> AsyncPipelinesRunsWithRawResponse:
+        """The runs API."""
+        return AsyncPipelinesRunsWithRawResponse(self._resource.runs)
+
+    @property
+    def stats(self) -> AsyncPipelinesStatsApiWithRawResponse:
+        """The stats API."""
+        return AsyncPipelinesStatsApiWithRawResponse(self._resource.stats)
+
+
+class Pipelines(ApiBaseSync):
+    """Pipelines API."""
+
+    @property
+    def with_raw_response(self) -> PipelinesWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return PipelinesWithRawResponse(self)
+
+    @functools.cached_property
+    def runs(self) -> PipelinesRuns:
+        """The runs API."""
+        return PipelinesRuns(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def stats(self) -> PipelinesStatsApi:
+        """The stats API."""
+        return PipelinesStatsApi(self._cfg, self._httpx_client)
+
+    def list(
+        self,
+        organization_id: UUID,
+        *,
+        page: int | None = None,
+        limit: int | None = None,
+        search: str | None = None,
+        status: PipelineStatusFilter | None = None,
+        harbor_id: UUID | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PipelinesListPage:
+        """`GET /api/v1/organizations/{organization_id}/pipelines`: the first page, iterate it for every item.
+
+        :param page: Zero-based page index. Absent or omitted defaults to the first page.
+        :param limit: Page size, clamped to `[1, 200]`. Absent defaults to 50.
+        :param search: Case-insensitive substring match on the pipeline name. Absent matches every name.
+        :param status: Filter by suspend state. Absent behaves like `all`.
+        :param harbor_id: Restrict to one harbor of this organization (exact match). Absent matches every pipeline in the org. The request is authorized against this harbor when it is given and against the whole organization when it is not, so a grant scoped to one harbor admits only a request that names that harbor."""
+
+        def fetch(page_param: int | None) -> PipelinesPage:
+            response = self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/organizations/{organization_id}/pipelines",
+                    path_params={
+                        "organization_id": encode_path_param(
+                            "organization_id", organization_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "page": page_param,
+                            "limit": limit,
+                            "search": search,
+                            "status": status,
+                            "harbor_id": harbor_id,
+                        },
+                    ),
+                    error_types={
+                        "default": _models.ApiErrorBody,
+                    },
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                    max_retries=max_retries,
+                )
+            )
+            return decode_response(response, PipelinesPage)
+
+        paging = PagePaging[PipelinesPage, PipelineResponseData](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return PipelinesListPage._first(fetch, page, paging)
+
+    def test_imap_connection(
+        self,
+        organization_id: UUID,
+        *,
+        folder: str,
+        host: str,
+        port: int,
+        username: str,
+        ca_cert: str | None | Unset = UNSET,
+        password: str | None | Unset = UNSET,
+        password_secret_id: UUID | None | Unset = UNSET,
+        use_tls: bool | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> TestImapConnectionResponse:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/test-imap-connection`.
+
+        :param password: The mailbox password, as a literal.  Optional since #4237: a caller whose password already lives in the secret manager sends `password_secret_id` instead, and exactly one of the two is required. Nothing is persisted either way — this endpoint opens a session and closes it — but the literal form means the password travels in a request body, and a console that only ever holds a secret id can now avoid that.
+        :param password_secret_id: A `plaintext` Passe-Partout secret in **this** organization holding the password.  Deliberately a bare id and not a `{organization_id, secret_id}` pair: the organization is the route's, so this endpoint cannot express a read outside the caller's own tenant. The secret is still put through the admission gate ([`SecretUsage::PipelineImapProbePassword`]), so one member cannot dereference another's private secret by probing a mail server with it."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/test-imap-connection",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    TestImapConnectionRequest(
+                        ca_cert=ca_cert,
+                        folder=folder,
+                        host=host,
+                        password=password,
+                        password_secret_id=password_secret_id,
+                        port=port,
+                        use_tls=use_tls,
+                        username=username,
+                    ),
+                    TestImapConnectionRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, TestImapConnectionResponse)
+
+    def retrieve(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PipelineDetailResponse:
+        """`GET /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PipelineDetailResponse)
+
+    def delete(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`DELETE /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`."""
+        self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def update(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        suspend: bool,
+        max_duration_minutes: int | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`PATCH /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}`.
+
+        :param max_duration_minutes: Wall-clock budget for one run, in minutes (1..=1440), or `null` to hand the budget back to the schedule — three times its interval, clamped into 15 minutes ..= 6 hours.  Applied as stated rather than as a patch, like `suspend` beside it: this is the value the pipeline should end up with. An omitted field therefore means "automatic", which is what every pipeline had before the column existed, so a caller written against the older shape is unaffected.
+        :param suspend: When true the underlying CronJob is suspended (no new runs will be scheduled)."""
+        self._request(
+            ApiRequest(
+                method="patch",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    UpdatePipelineRequest(
+                        max_duration_minutes=max_duration_minutes,
+                        suspend=suspend,
+                    ),
+                    UpdatePipelineRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def update_config(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        body: UpdatePipelineConfigRequest,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """Update a SharePoint or GDrive connector's settings - site/library/folder,
+        service-account/tenant credential, destination bucket/prefix, schedule -
+        without recreating the pipeline. See `UpdatePipelineConfigRequest`'s own
+        doc comment for what stays fixed (name, harbor, extraction) and why."""
+        self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/config",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(body, UpdatePipelineConfigRequest),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def refresh_credentials(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> RefreshCredentialsSummary:
+        """Re-resolves S3 credentials for every S3 connection in the pipeline CRD and
+        patches the CRD `spec.pipelineConfig.raw`. Intended to be called after an
+        org has migrated off a legacy DataDock to the shared per-Org RGW (#2228) so
+        scheduled pipeline runs pick up the new credentials without operator
+        recreating the pipeline.
+
+        Returns:
+        - `200` with the per-connection backing sources on success
+        - `404` if neither the DB row nor the CRD for the pipeline exists
+        - `409` if the pipeline currently has a run in `Running` status — swapping
+           creds out from under a running task would corrupt the in-flight transfer
+        - `409` if the pipeline's CR runs outside its environment's namespace, where
+           no refresh can reach it; deleting the pipeline and creating it again can"""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refresh-credentials",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, RefreshCredentialsSummary)
+
+    def count_pipeline_refs(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        status: RefStatus | None = None,
+        key: str | None = None,
+        locked: bool | None = None,
+        updated_at_before: datetime | None = None,
+        updated_at_after: datetime | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> str:
+        """`GET /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refs`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/refs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "status": status,
+                        "key": key,
+                        "locked": locked,
+                        "updated_at_before": updated_at_before,
+                        "updated_at_after": updated_at_after,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return response.text
+
+    def resume(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/resume`."""
+        self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/resume",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def suspend(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/suspend`."""
+        self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/suspend",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def trigger(
+        self,
+        organization_id: UUID,
+        pipeline_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`POST /api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/trigger`."""
+        self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/organizations/{organization_id}/pipelines/{pipeline_id}/trigger",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "pipeline_id": encode_path_param(
+                        "pipeline_id", pipeline_id, "simple", False
+                    ),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+    def count_refs(
+        self,
+        *,
+        key: str | None | Unset = UNSET,
+        locked: bool | None | Unset = UNSET,
+        pipeline_id: UUID | None | Unset = UNSET,
+        status: RefStatus | RefStatusLiteral | None | Unset = UNSET,
+        updated_at_after: datetime | None | Unset = UNSET,
+        updated_at_before: datetime | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> str:
+        """`POST /api/v1/refs/count`."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/refs/count",
+                json_body=to_json_value(
+                    CountRefRequest(
+                        key=key,
+                        locked=locked,
+                        pipeline_id=pipeline_id,
+                        status=t.cast("RefStatus | None | Unset", status),
+                        updated_at_after=updated_at_after,
+                        updated_at_before=updated_at_before,
+                    ),
+                    CountRefRequest,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return response.text
+
+    def list_refs_list(
+        self,
+        *,
+        pipeline_id: UUID | None = None,
+        pipeline_checksum: str | None = None,
+        status: RefStatus | None = None,
+        key: str | None = None,
+        updated_at_before: datetime | None = None,
+        updated_at_after: datetime | None = None,
+        lock: bool | None = None,
+        locked_by: UUID | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> builtins.list[Ref]:
+        """`GET /api/v1/refs/list`.
+
+        :param lock: Whether to lock the references listed"""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/refs/list",
+                query_params=serialize_query_params(
+                    {
+                        "pipeline_id": pipeline_id,
+                        "pipeline_checksum": pipeline_checksum,
+                        "status": status,
+                        "key": key,
+                        "updated_at_before": updated_at_before,
+                        "updated_at_after": updated_at_after,
+                        "lock": lock,
+                        "locked_by": locked_by,
+                        "limit": limit,
+                        "offset": offset,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[Ref])
+
+    def create_many_refs(
+        self,
+        body: builtins.list[CreateRefRequest],
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> builtins.list[Ref]:
+        """Registers refs in bulk, each with the status its entry names (absent means
+        `pending`).
+
+        Insert-only: a `(pipeline_id, pipeline_checksum, key)` that already exists keeps
+        the status it has and is NOT returned, so the reply is the rows actually created
+        and a `200 []` means every key was already there. This route cannot promote an
+        existing ref.
+
+        On the external router the batch must name exactly one pipeline and must not be
+        empty — that is the resource the request is authorized against — and a body that
+        breaks either rule answers 422 without reaching the authorization decision."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/refs/many",
+                json_body=to_json_value(body, list[CreateRefRequest]),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[Ref])
+
+    def update_ref(
+        self,
+        key: str,
+        body: UpdateRefRequest,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> Ref:
+        """`PUT /api/v1/refs/{key}`."""
+        response = self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/refs/{key}",
+                path_params={
+                    "key": key,
+                },
+                json_body=to_json_value(body, UpdateRefRequest),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, Ref)
+
+    def create(
+        self,
+        body: CreatePipelineRequestV2,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PipelineResponseData:
+        """Creates a pipeline CRD using the new V2 API with discriminated union"""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v2/pipelines",
+                json_body=to_json_value(body, CreatePipelineRequestV2),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PipelineResponseData)
+
+
+class PipelinesWithRawResponse:
+    """The methods of :class:`Pipelines`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: Pipelines) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.test_imap_connection = to_raw_response_wrapper(
+            resource.test_imap_connection
+        )
+        self.retrieve = to_raw_response_wrapper(resource.retrieve)
+        self.delete = to_raw_response_wrapper(resource.delete)
+        self.update = to_raw_response_wrapper(resource.update)
+        self.update_config = to_raw_response_wrapper(resource.update_config)
+        self.refresh_credentials = to_raw_response_wrapper(resource.refresh_credentials)
+        self.count_pipeline_refs = to_raw_response_wrapper(resource.count_pipeline_refs)
+        self.resume = to_raw_response_wrapper(resource.resume)
+        self.suspend = to_raw_response_wrapper(resource.suspend)
+        self.trigger = to_raw_response_wrapper(resource.trigger)
+        self.count_refs = to_raw_response_wrapper(resource.count_refs)
+        self.list_refs_list = to_raw_response_wrapper(resource.list_refs_list)
+        self.create_many_refs = to_raw_response_wrapper(resource.create_many_refs)
+        self.update_ref = to_raw_response_wrapper(resource.update_ref)
+        self.create = to_raw_response_wrapper(resource.create)
+
+    @property
+    def runs(self) -> PipelinesRunsWithRawResponse:
+        """The runs API."""
+        return PipelinesRunsWithRawResponse(self._resource.runs)
+
+    @property
+    def stats(self) -> PipelinesStatsApiWithRawResponse:
+        """The stats API."""
+        return PipelinesStatsApiWithRawResponse(self._resource.stats)