hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/api/petite_requete.py

@@ -0,0 +1,1945 @@
+# this file is @generated
+"""Petite requete API."""
+
+from __future__ import annotations
+
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    AnalyticsSummary,
+    AnalyticsTrends,
+    CreateSavedQueryRequest,
+    ExecuteRequest,
+    QueryHistoryEntry,
+    QueryHistoryPage,
+    QueryResult,
+    QueryRun,
+    ResultsPage,
+    SavedQueriesPage,
+    SavedQuery,
+    SavedQuerySort,
+    SortDir,
+    SqlCopilotRepairContext,
+    SqlCopilotRequest,
+    SqlCopilotResponse,
+    TinyQueryLimitsResponse,
+    TrinoMetadata,
+    UpdateSavedQueryRequest,
+)
+from ..serialization import UNSET, Unset, to_json_value
+from ._pages import (
+    AsyncPetiteRequeteListHarborTinyQueryHistoryPage,
+    AsyncPetiteRequeteListHarborTinyQueryQueriesPage,
+    PetiteRequeteListHarborTinyQueryHistoryPage,
+    PetiteRequeteListHarborTinyQueryQueriesPage,
+)
+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,
+)
+
+
+class AsyncPetiteRequete(ApiBaseAsync):
+    """Petite requete API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncPetiteRequeteWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncPetiteRequeteWithRawResponse(self)
+
+    async def list_harbor_tiny_query_analytics_slow_queries(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_id: UUID | None = None,
+        limit: int | None = None,
+        sort_by: str | 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,
+    ) -> list[QueryHistoryEntry]:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/slow-queries`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock
+        :param limit: Max results (default 10, max 50)
+        :param sort_by: Sort by: execution_time, peak_memory, bytes_scanned"""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/slow-queries",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_id,
+                        "limit": limit,
+                        "sort_by": sort_by,
+                    },
+                ),
+                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[QueryHistoryEntry])
+
+    async def retrieve_harbor_tiny_query_analytics_summary(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_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,
+    ) -> AnalyticsSummary:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/summary`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock"""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/summary",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_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, AnalyticsSummary)
+
+    async def list_harbor_tiny_query_analytics_trends(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_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,
+    ) -> AnalyticsTrends:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/trends`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock"""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/trends",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_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, AnalyticsTrends)
+
+    def list_harbor_tiny_query_history(
+        self,
+        harbor_id: UUID,
+        *,
+        data_dock_id: UUID | None = None,
+        status: str | None = None,
+        statement_type: str | None = None,
+        search: str | None = None,
+        scheduled_query_id: UUID | None = None,
+        page: int | None = None,
+        per_page: 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,
+    ) -> AsyncPaginator[
+        QueryHistoryEntry, AsyncPetiteRequeteListHarborTinyQueryHistoryPage
+    ]:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/history`: the first page, iterate it for every item.
+
+        :param data_dock_id: Filter by Data Dock
+        :param status: Filter: running, completed, failed, cancelled
+        :param statement_type: Filter: SELECT, INSERT, CTAS, DDL
+        :param search: Search in SQL text
+        :param scheduled_query_id: Scope to one scheduled query's run history (org-wide, not limited to the caller's own runs)
+        :param page: Page number (default 0)
+        :param per_page: Items per page (default 50, max 200)"""
+
+        async def fetch(page_param: int | None) -> QueryHistoryPage:
+            response = await self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/harbors/{harbor_id}/tiny-query/history",
+                    path_params={
+                        "harbor_id": encode_path_param(
+                            "harbor_id", harbor_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "data_dock_id": data_dock_id,
+                            "status": status,
+                            "statement_type": statement_type,
+                            "search": search,
+                            "scheduled_query_id": scheduled_query_id,
+                            "page": page_param,
+                            "per_page": per_page,
+                        },
+                    ),
+                    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, QueryHistoryPage)
+
+        paging = PagePaging[QueryHistoryPage, QueryHistoryEntry](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return AsyncPaginator(
+            lambda: AsyncPetiteRequeteListHarborTinyQueryHistoryPage._first(
+                fetch, page, paging
+            )
+        )
+
+    async def list_harbor_tiny_query_limits(
+        self,
+        harbor_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,
+    ) -> TinyQueryLimitsResponse:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/limits`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/limits",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_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, TinyQueryLimitsResponse)
+
+    def list_harbor_tiny_query_queries(
+        self,
+        harbor_id: UUID,
+        *,
+        data_dock_id: UUID | None = None,
+        visibility: str | None = None,
+        search: str | None = None,
+        mine: bool | None = None,
+        scheduled: bool | None = None,
+        failing: bool | None = None,
+        suspended: bool | None = None,
+        never_run: bool | None = None,
+        sort: SavedQuerySort | None = None,
+        dir: SortDir | None = None,
+        page: int | None = None,
+        limit: 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,
+    ) -> AsyncPaginator[SavedQuery, AsyncPetiteRequeteListHarborTinyQueryQueriesPage]:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/queries`: the first page, iterate it for every item.
+
+        :param data_dock_id: Filter by Data Dock
+        :param visibility: Filter: private or team
+        :param search: Search in title/description
+        :param mine: Only my queries
+        :param scheduled: true: only scheduled queries, false: only unscheduled ones
+        :param failing: true: only queries failing 3+ runs in a row
+        :param suspended: true: only paused schedules, false: only live ones
+        :param never_run: true: only schedules that have never attempted a run
+        :param sort: Column to order by. Absent defaults to updated_at descending.
+        :param dir: Sort direction; ignored without `sort`. Defaults to asc.
+        :param page: Zero-based page index. Absent defaults to the first page.
+        :param limit: Page size, clamped to [1, 200]. Absent defaults to 50."""
+
+        async def fetch(page_param: int | None) -> SavedQueriesPage:
+            response = await self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/harbors/{harbor_id}/tiny-query/queries",
+                    path_params={
+                        "harbor_id": encode_path_param(
+                            "harbor_id", harbor_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "data_dock_id": data_dock_id,
+                            "visibility": visibility,
+                            "search": search,
+                            "mine": mine,
+                            "scheduled": scheduled,
+                            "failing": failing,
+                            "suspended": suspended,
+                            "never_run": never_run,
+                            "sort": sort,
+                            "dir": dir,
+                            "page": page_param,
+                            "limit": limit,
+                        },
+                    ),
+                    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, SavedQueriesPage)
+
+        paging = PagePaging[SavedQueriesPage, SavedQuery](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return AsyncPaginator(
+            lambda: AsyncPetiteRequeteListHarborTinyQueryQueriesPage._first(
+                fetch, page, paging
+            )
+        )
+
+    async def tiny_query_copilot_generate(
+        self,
+        *,
+        data_dock_id: UUID,
+        model: str | None | Unset = UNSET,
+        prompt: str | None = None,
+        repair: SqlCopilotRepairContext | 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,
+    ) -> SqlCopilotResponse:
+        """NL → SQL. The schema grounding is fetched with the *caller's* JWT (same
+        trust boundary as the SQL editor and `execute_query_handler`). Unlike the
+        dashboards copilot, the result is not restricted to SELECT — Tiny Query is
+        a general SQL IDE — and it lands in the editor as a draft; running it is
+        still a separate, explicit action. One repair round if the generated SQL
+        fails schema validation (`TinyQueryService::validate_sql`, a
+        non-executing `EXPLAIN (TYPE VALIDATE)`), so a hallucinated table/column
+        name is corrected — or clearly still wrong — before the caller sees it,
+        rather than silently returned.
+
+        :param data_dock_id: Data Dock whose schema grounds the generation.
+        :param model: Model override; defaults to the platform's generation model.
+        :param prompt: The user's natural-language ask ("insert a daily rollup of order totals into a new table"). May be empty when `repair` drives the request."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/copilot/generate",
+                json_body=to_json_value(
+                    SqlCopilotRequest(
+                        data_dock_id=data_dock_id,
+                        model=model,
+                        prompt=prompt,
+                        repair=repair,
+                    ),
+                    SqlCopilotRequest,
+                ),
+                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, SqlCopilotResponse)
+
+    async def tiny_query_execute(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql: str,
+        limit: int | None | Unset = UNSET,
+        query_id: UUID | None | Unset = UNSET,
+        timeout_seconds: 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,
+    ) -> QueryResult:
+        """Run a query and wait for its result
+
+        The request stays silent for the whole run, so a gateway idle timeout
+        (300 s on Cilium) cuts off a longer one: start those with
+        `POST /api/v1/tiny-query/runs` and poll instead.
+
+        :param query_id: Id for the run's history entry, chosen by the caller so it can cancel the run while it executes. Generated server-side when absent.
+        :param timeout_seconds: Seconds before the statement is cancelled. Must sit inside the range `GET /api/v1/harbors/{harbor_id}/tiny-query/limits` returns; omitted, the server default applies."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/execute",
+                json_body=to_json_value(
+                    ExecuteRequest(
+                        data_dock_id=data_dock_id,
+                        limit=limit,
+                        query_id=query_id,
+                        sql=sql,
+                        timeout_seconds=timeout_seconds,
+                    ),
+                    ExecuteRequest,
+                ),
+                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, QueryResult)
+
+    async def retrieve_tiny_query_history(
+        self,
+        history_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,
+    ) -> QueryHistoryEntry:
+        """A single run's full detail, including its (possibly truncated) output —
+        unlike the list endpoint, which never selects `result_data` to stay light
+        for the interactive History tab. Org-scoped, not restricted to the
+        entry's own `user_id`: a scheduled run executes under the schedule's
+        owner, not necessarily the viewer, and anyone who can see the scheduled
+        query on the Data Engineering list can already see that it ran."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/history/{history_id}",
+                path_params={
+                    "history_id": encode_path_param(
+                        "history_id", history_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, QueryHistoryEntry)
+
+    async def cancel_tiny_query_history(
+        self,
+        history_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:
+        """Cancel a running query by its history id — the `query_id` the caller sent
+        to `/execute`, so it is known while the query runs."""
+        await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/history/{history_id}/cancel",
+                path_params={
+                    "history_id": encode_path_param(
+                        "history_id", history_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 create_tiny_query_query(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql_text: str,
+        title: str,
+        alert_on_failure: bool | None | Unset = UNSET,
+        description: str | None | Unset = UNSET,
+        schedule: str | None | Unset = UNSET,
+        service_account_id: UUID | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        visibility: str | 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,
+    ) -> SavedQuery:
+        """`POST /api/v1/tiny-query/queries`.
+
+        :param alert_on_failure: Whether the schedule gets its default "keeps failing" alert rule. Omitted means yes.
+        :param schedule: Cron expression. Omitted or `null` means the query only runs on demand.
+        :param service_account_id: The service account the schedule runs as. Required whenever `schedule` is set, ignored otherwise — an on-demand query runs on its caller's own token and needs no standing identity."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/queries",
+                json_body=to_json_value(
+                    CreateSavedQueryRequest(
+                        alert_on_failure=alert_on_failure,
+                        data_dock_id=data_dock_id,
+                        description=description,
+                        schedule=schedule,
+                        service_account_id=service_account_id,
+                        sql_text=sql_text,
+                        tags=tags,
+                        title=title,
+                        visibility=visibility,
+                    ),
+                    CreateSavedQueryRequest,
+                ),
+                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, SavedQuery)
+
+    async def retrieve_tiny_query_query(
+        self,
+        query_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,
+    ) -> SavedQuery:
+        """`GET /api/v1/tiny-query/queries/{query_id}`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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, SavedQuery)
+
+    async def update_tiny_query_query(
+        self,
+        query_id: UUID,
+        *,
+        alert_on_failure: bool | None | Unset = UNSET,
+        description: str | None | Unset = UNSET,
+        schedule: str | None | Unset = UNSET,
+        service_account_id: UUID | None | Unset = UNSET,
+        sql_text: str | None | Unset = UNSET,
+        suspended: bool | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        title: str | None | Unset = UNSET,
+        visibility: str | 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,
+    ) -> SavedQuery:
+        """`PUT /api/v1/tiny-query/queries/{query_id}`.
+
+        :param alert_on_failure: Omitted leaves the alert choice unchanged.
+        :param schedule: Absent = keep the current schedule; `null` = unschedule the query; a string = replace the cron.  This is a double option on purpose. With a plain `Option<String>` serde folds "absent" and "explicit null" together, and the repository's `.or(current)` fallback then writes the old cron back — which left no request at all that could stop a scheduled query.
+        :param service_account_id: Absent = keep the current account; a value = reassign the schedule to it. Deliberately *not* a double option: there is no request that detaches an account while leaving the schedule active, because that would be a schedule nothing can authorize. Clearing the `schedule` clears this alongside it.
+        :param suspended: Omitted leaves suspended state unchanged. `Some(false)` (an explicit resume) with no schedule text change also recomputes `next_run_at` fresh from now, rather than firing immediately on a stale, long-past value."""
+        response = await self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    UpdateSavedQueryRequest(
+                        alert_on_failure=alert_on_failure,
+                        description=description,
+                        schedule=schedule,
+                        service_account_id=service_account_id,
+                        sql_text=sql_text,
+                        suspended=suspended,
+                        tags=tags,
+                        title=title,
+                        visibility=visibility,
+                    ),
+                    UpdateSavedQueryRequest,
+                ),
+                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, SavedQuery)
+
+    async def delete_tiny_query_query(
+        self,
+        query_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/tiny-query/queries/{query_id}`."""
+        await self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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 run_tiny_query_query(
+        self,
+        query_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,
+    ) -> QueryResult:
+        """Executes a scheduled query's SQL on demand, under the *caller's* own
+        session (same trust boundary as `execute_query_handler`) — not the
+        schedule owner's identity, so this never depends on the owner having
+        granted background execution. Writes to `query_history` like any run
+        (visible in the run-history detail view, output included) but never
+        updates the schedule's own tracked health."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/queries/{query_id}/run",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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, QueryResult)
+
+    async def retrieve_tiny_query_result(
+        self,
+        query_id: UUID,
+        *,
+        offset: int | None = None,
+        limit: 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,
+    ) -> ResultsPage:
+        """`GET /api/v1/tiny-query/results/{query_id}`.
+
+        :param offset: Row offset (default 0)
+        :param limit: Number of rows (default 500)"""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/results/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "offset": offset,
+                        "limit": limit,
+                    },
+                ),
+                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, ResultsPage)
+
+    async def create_tiny_query_run(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql: str,
+        limit: int | None | Unset = UNSET,
+        query_id: UUID | None | Unset = UNSET,
+        timeout_seconds: 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,
+    ) -> QueryRun:
+        """Start a query run
+
+        Answers at once with the run's id; poll `GET /api/v1/tiny-query/runs/{query_id}`
+        for its outcome. Takes the same body as `POST /api/v1/tiny-query/execute`.
+
+        :param query_id: Id for the run's history entry, chosen by the caller so it can cancel the run while it executes. Generated server-side when absent.
+        :param timeout_seconds: Seconds before the statement is cancelled. Must sit inside the range `GET /api/v1/harbors/{harbor_id}/tiny-query/limits` returns; omitted, the server default applies."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/runs",
+                json_body=to_json_value(
+                    ExecuteRequest(
+                        data_dock_id=data_dock_id,
+                        limit=limit,
+                        query_id=query_id,
+                        sql=sql,
+                        timeout_seconds=timeout_seconds,
+                    ),
+                    ExecuteRequest,
+                ),
+                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, QueryRun)
+
+    async def retrieve_tiny_query_run(
+        self,
+        query_id: UUID,
+        *,
+        wait_seconds: 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,
+    ) -> QueryRun:
+        """Poll a query run
+
+        Waits up to `wait_seconds` for the run to end, then answers where it stands:
+        `running`, `completed` with the first page of rows, or `failed` with the
+        status and message `POST /api/v1/tiny-query/execute` would have returned.
+
+        :param wait_seconds: Seconds to wait for the run to finish before answering `running` (0 to 30, default 0)."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/runs/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "wait_seconds": wait_seconds,
+                    },
+                ),
+                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, QueryRun)
+
+    async def retrieve_tiny_query_schema(
+        self,
+        data_dock_id: UUID,
+        *,
+        refresh: 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,
+    ) -> TrinoMetadata:
+        """`GET /api/v1/tiny-query/schema/{data_dock_id}`.
+
+        :param refresh: Re-introspect the cluster instead of serving the cached schema.  This is what the schema browser's refresh button sends. Absent or `false` is the normal path and answers from cache while it is warm."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/schema/{data_dock_id}",
+                path_params={
+                    "data_dock_id": encode_path_param(
+                        "data_dock_id", data_dock_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "refresh": refresh,
+                    },
+                ),
+                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, TrinoMetadata)
+
+
+class AsyncPetiteRequeteWithRawResponse:
+    """The methods of :class:`AsyncPetiteRequete`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncPetiteRequete) -> None:
+        self.list_harbor_tiny_query_analytics_slow_queries = (
+            async_to_raw_response_wrapper(
+                resource.list_harbor_tiny_query_analytics_slow_queries
+            )
+        )
+        self.retrieve_harbor_tiny_query_analytics_summary = (
+            async_to_raw_response_wrapper(
+                resource.retrieve_harbor_tiny_query_analytics_summary
+            )
+        )
+        self.list_harbor_tiny_query_analytics_trends = async_to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_analytics_trends
+        )
+        self.list_harbor_tiny_query_history = async_to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_history
+        )
+        self.list_harbor_tiny_query_limits = async_to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_limits
+        )
+        self.list_harbor_tiny_query_queries = async_to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_queries
+        )
+        self.tiny_query_copilot_generate = async_to_raw_response_wrapper(
+            resource.tiny_query_copilot_generate
+        )
+        self.tiny_query_execute = async_to_raw_response_wrapper(
+            resource.tiny_query_execute
+        )
+        self.retrieve_tiny_query_history = async_to_raw_response_wrapper(
+            resource.retrieve_tiny_query_history
+        )
+        self.cancel_tiny_query_history = async_to_raw_response_wrapper(
+            resource.cancel_tiny_query_history
+        )
+        self.create_tiny_query_query = async_to_raw_response_wrapper(
+            resource.create_tiny_query_query
+        )
+        self.retrieve_tiny_query_query = async_to_raw_response_wrapper(
+            resource.retrieve_tiny_query_query
+        )
+        self.update_tiny_query_query = async_to_raw_response_wrapper(
+            resource.update_tiny_query_query
+        )
+        self.delete_tiny_query_query = async_to_raw_response_wrapper(
+            resource.delete_tiny_query_query
+        )
+        self.run_tiny_query_query = async_to_raw_response_wrapper(
+            resource.run_tiny_query_query
+        )
+        self.retrieve_tiny_query_result = async_to_raw_response_wrapper(
+            resource.retrieve_tiny_query_result
+        )
+        self.create_tiny_query_run = async_to_raw_response_wrapper(
+            resource.create_tiny_query_run
+        )
+        self.retrieve_tiny_query_run = async_to_raw_response_wrapper(
+            resource.retrieve_tiny_query_run
+        )
+        self.retrieve_tiny_query_schema = async_to_raw_response_wrapper(
+            resource.retrieve_tiny_query_schema
+        )
+
+
+class PetiteRequete(ApiBaseSync):
+    """Petite requete API."""
+
+    @property
+    def with_raw_response(self) -> PetiteRequeteWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return PetiteRequeteWithRawResponse(self)
+
+    def list_harbor_tiny_query_analytics_slow_queries(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_id: UUID | None = None,
+        limit: int | None = None,
+        sort_by: str | 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,
+    ) -> list[QueryHistoryEntry]:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/slow-queries`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock
+        :param limit: Max results (default 10, max 50)
+        :param sort_by: Sort by: execution_time, peak_memory, bytes_scanned"""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/slow-queries",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_id,
+                        "limit": limit,
+                        "sort_by": sort_by,
+                    },
+                ),
+                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[QueryHistoryEntry])
+
+    def retrieve_harbor_tiny_query_analytics_summary(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_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,
+    ) -> AnalyticsSummary:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/summary`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock"""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/summary",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_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, AnalyticsSummary)
+
+    def list_harbor_tiny_query_analytics_trends(
+        self,
+        harbor_id: UUID,
+        *,
+        time_range: str | None = None,
+        data_dock_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,
+    ) -> AnalyticsTrends:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/analytics/trends`.
+
+        :param time_range: Time range: 1h, 6h, 24h, 7d, 30d (default 24h)
+        :param data_dock_id: Filter by Data Dock"""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/analytics/trends",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "time_range": time_range,
+                        "data_dock_id": data_dock_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, AnalyticsTrends)
+
+    def list_harbor_tiny_query_history(
+        self,
+        harbor_id: UUID,
+        *,
+        data_dock_id: UUID | None = None,
+        status: str | None = None,
+        statement_type: str | None = None,
+        search: str | None = None,
+        scheduled_query_id: UUID | None = None,
+        page: int | None = None,
+        per_page: 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,
+    ) -> PetiteRequeteListHarborTinyQueryHistoryPage:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/history`: the first page, iterate it for every item.
+
+        :param data_dock_id: Filter by Data Dock
+        :param status: Filter: running, completed, failed, cancelled
+        :param statement_type: Filter: SELECT, INSERT, CTAS, DDL
+        :param search: Search in SQL text
+        :param scheduled_query_id: Scope to one scheduled query's run history (org-wide, not limited to the caller's own runs)
+        :param page: Page number (default 0)
+        :param per_page: Items per page (default 50, max 200)"""
+
+        def fetch(page_param: int | None) -> QueryHistoryPage:
+            response = self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/harbors/{harbor_id}/tiny-query/history",
+                    path_params={
+                        "harbor_id": encode_path_param(
+                            "harbor_id", harbor_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "data_dock_id": data_dock_id,
+                            "status": status,
+                            "statement_type": statement_type,
+                            "search": search,
+                            "scheduled_query_id": scheduled_query_id,
+                            "page": page_param,
+                            "per_page": per_page,
+                        },
+                    ),
+                    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, QueryHistoryPage)
+
+        paging = PagePaging[QueryHistoryPage, QueryHistoryEntry](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return PetiteRequeteListHarborTinyQueryHistoryPage._first(fetch, page, paging)
+
+    def list_harbor_tiny_query_limits(
+        self,
+        harbor_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,
+    ) -> TinyQueryLimitsResponse:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/limits`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/harbors/{harbor_id}/tiny-query/limits",
+                path_params={
+                    "harbor_id": encode_path_param(
+                        "harbor_id", harbor_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, TinyQueryLimitsResponse)
+
+    def list_harbor_tiny_query_queries(
+        self,
+        harbor_id: UUID,
+        *,
+        data_dock_id: UUID | None = None,
+        visibility: str | None = None,
+        search: str | None = None,
+        mine: bool | None = None,
+        scheduled: bool | None = None,
+        failing: bool | None = None,
+        suspended: bool | None = None,
+        never_run: bool | None = None,
+        sort: SavedQuerySort | None = None,
+        dir: SortDir | None = None,
+        page: int | None = None,
+        limit: 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,
+    ) -> PetiteRequeteListHarborTinyQueryQueriesPage:
+        """`GET /api/v1/harbors/{harbor_id}/tiny-query/queries`: the first page, iterate it for every item.
+
+        :param data_dock_id: Filter by Data Dock
+        :param visibility: Filter: private or team
+        :param search: Search in title/description
+        :param mine: Only my queries
+        :param scheduled: true: only scheduled queries, false: only unscheduled ones
+        :param failing: true: only queries failing 3+ runs in a row
+        :param suspended: true: only paused schedules, false: only live ones
+        :param never_run: true: only schedules that have never attempted a run
+        :param sort: Column to order by. Absent defaults to updated_at descending.
+        :param dir: Sort direction; ignored without `sort`. Defaults to asc.
+        :param page: Zero-based page index. Absent defaults to the first page.
+        :param limit: Page size, clamped to [1, 200]. Absent defaults to 50."""
+
+        def fetch(page_param: int | None) -> SavedQueriesPage:
+            response = self._request(
+                ApiRequest(
+                    method="get",
+                    path="/api/v1/harbors/{harbor_id}/tiny-query/queries",
+                    path_params={
+                        "harbor_id": encode_path_param(
+                            "harbor_id", harbor_id, "simple", False
+                        ),
+                    },
+                    query_params=serialize_query_params(
+                        {
+                            "data_dock_id": data_dock_id,
+                            "visibility": visibility,
+                            "search": search,
+                            "mine": mine,
+                            "scheduled": scheduled,
+                            "failing": failing,
+                            "suspended": suspended,
+                            "never_run": never_run,
+                            "sort": sort,
+                            "dir": dir,
+                            "page": page_param,
+                            "limit": limit,
+                        },
+                    ),
+                    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, SavedQueriesPage)
+
+        paging = PagePaging[SavedQueriesPage, SavedQuery](
+            items=lambda body: body.data,
+            first_page=0,
+        )
+        return PetiteRequeteListHarborTinyQueryQueriesPage._first(fetch, page, paging)
+
+    def tiny_query_copilot_generate(
+        self,
+        *,
+        data_dock_id: UUID,
+        model: str | None | Unset = UNSET,
+        prompt: str | None = None,
+        repair: SqlCopilotRepairContext | 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,
+    ) -> SqlCopilotResponse:
+        """NL → SQL. The schema grounding is fetched with the *caller's* JWT (same
+        trust boundary as the SQL editor and `execute_query_handler`). Unlike the
+        dashboards copilot, the result is not restricted to SELECT — Tiny Query is
+        a general SQL IDE — and it lands in the editor as a draft; running it is
+        still a separate, explicit action. One repair round if the generated SQL
+        fails schema validation (`TinyQueryService::validate_sql`, a
+        non-executing `EXPLAIN (TYPE VALIDATE)`), so a hallucinated table/column
+        name is corrected — or clearly still wrong — before the caller sees it,
+        rather than silently returned.
+
+        :param data_dock_id: Data Dock whose schema grounds the generation.
+        :param model: Model override; defaults to the platform's generation model.
+        :param prompt: The user's natural-language ask ("insert a daily rollup of order totals into a new table"). May be empty when `repair` drives the request."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/copilot/generate",
+                json_body=to_json_value(
+                    SqlCopilotRequest(
+                        data_dock_id=data_dock_id,
+                        model=model,
+                        prompt=prompt,
+                        repair=repair,
+                    ),
+                    SqlCopilotRequest,
+                ),
+                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, SqlCopilotResponse)
+
+    def tiny_query_execute(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql: str,
+        limit: int | None | Unset = UNSET,
+        query_id: UUID | None | Unset = UNSET,
+        timeout_seconds: 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,
+    ) -> QueryResult:
+        """Run a query and wait for its result
+
+        The request stays silent for the whole run, so a gateway idle timeout
+        (300 s on Cilium) cuts off a longer one: start those with
+        `POST /api/v1/tiny-query/runs` and poll instead.
+
+        :param query_id: Id for the run's history entry, chosen by the caller so it can cancel the run while it executes. Generated server-side when absent.
+        :param timeout_seconds: Seconds before the statement is cancelled. Must sit inside the range `GET /api/v1/harbors/{harbor_id}/tiny-query/limits` returns; omitted, the server default applies."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/execute",
+                json_body=to_json_value(
+                    ExecuteRequest(
+                        data_dock_id=data_dock_id,
+                        limit=limit,
+                        query_id=query_id,
+                        sql=sql,
+                        timeout_seconds=timeout_seconds,
+                    ),
+                    ExecuteRequest,
+                ),
+                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, QueryResult)
+
+    def retrieve_tiny_query_history(
+        self,
+        history_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,
+    ) -> QueryHistoryEntry:
+        """A single run's full detail, including its (possibly truncated) output —
+        unlike the list endpoint, which never selects `result_data` to stay light
+        for the interactive History tab. Org-scoped, not restricted to the
+        entry's own `user_id`: a scheduled run executes under the schedule's
+        owner, not necessarily the viewer, and anyone who can see the scheduled
+        query on the Data Engineering list can already see that it ran."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/history/{history_id}",
+                path_params={
+                    "history_id": encode_path_param(
+                        "history_id", history_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, QueryHistoryEntry)
+
+    def cancel_tiny_query_history(
+        self,
+        history_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:
+        """Cancel a running query by its history id — the `query_id` the caller sent
+        to `/execute`, so it is known while the query runs."""
+        self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/history/{history_id}/cancel",
+                path_params={
+                    "history_id": encode_path_param(
+                        "history_id", history_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 create_tiny_query_query(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql_text: str,
+        title: str,
+        alert_on_failure: bool | None | Unset = UNSET,
+        description: str | None | Unset = UNSET,
+        schedule: str | None | Unset = UNSET,
+        service_account_id: UUID | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        visibility: str | 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,
+    ) -> SavedQuery:
+        """`POST /api/v1/tiny-query/queries`.
+
+        :param alert_on_failure: Whether the schedule gets its default "keeps failing" alert rule. Omitted means yes.
+        :param schedule: Cron expression. Omitted or `null` means the query only runs on demand.
+        :param service_account_id: The service account the schedule runs as. Required whenever `schedule` is set, ignored otherwise — an on-demand query runs on its caller's own token and needs no standing identity."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/queries",
+                json_body=to_json_value(
+                    CreateSavedQueryRequest(
+                        alert_on_failure=alert_on_failure,
+                        data_dock_id=data_dock_id,
+                        description=description,
+                        schedule=schedule,
+                        service_account_id=service_account_id,
+                        sql_text=sql_text,
+                        tags=tags,
+                        title=title,
+                        visibility=visibility,
+                    ),
+                    CreateSavedQueryRequest,
+                ),
+                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, SavedQuery)
+
+    def retrieve_tiny_query_query(
+        self,
+        query_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,
+    ) -> SavedQuery:
+        """`GET /api/v1/tiny-query/queries/{query_id}`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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, SavedQuery)
+
+    def update_tiny_query_query(
+        self,
+        query_id: UUID,
+        *,
+        alert_on_failure: bool | None | Unset = UNSET,
+        description: str | None | Unset = UNSET,
+        schedule: str | None | Unset = UNSET,
+        service_account_id: UUID | None | Unset = UNSET,
+        sql_text: str | None | Unset = UNSET,
+        suspended: bool | None | Unset = UNSET,
+        tags: list[str] | None | Unset = UNSET,
+        title: str | None | Unset = UNSET,
+        visibility: str | 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,
+    ) -> SavedQuery:
+        """`PUT /api/v1/tiny-query/queries/{query_id}`.
+
+        :param alert_on_failure: Omitted leaves the alert choice unchanged.
+        :param schedule: Absent = keep the current schedule; `null` = unschedule the query; a string = replace the cron.  This is a double option on purpose. With a plain `Option<String>` serde folds "absent" and "explicit null" together, and the repository's `.or(current)` fallback then writes the old cron back — which left no request at all that could stop a scheduled query.
+        :param service_account_id: Absent = keep the current account; a value = reassign the schedule to it. Deliberately *not* a double option: there is no request that detaches an account while leaving the schedule active, because that would be a schedule nothing can authorize. Clearing the `schedule` clears this alongside it.
+        :param suspended: Omitted leaves suspended state unchanged. `Some(false)` (an explicit resume) with no schedule text change also recomputes `next_run_at` fresh from now, rather than firing immediately on a stale, long-past value."""
+        response = self._request(
+            ApiRequest(
+                method="put",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                json_body=to_json_value(
+                    UpdateSavedQueryRequest(
+                        alert_on_failure=alert_on_failure,
+                        description=description,
+                        schedule=schedule,
+                        service_account_id=service_account_id,
+                        sql_text=sql_text,
+                        suspended=suspended,
+                        tags=tags,
+                        title=title,
+                        visibility=visibility,
+                    ),
+                    UpdateSavedQueryRequest,
+                ),
+                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, SavedQuery)
+
+    def delete_tiny_query_query(
+        self,
+        query_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/tiny-query/queries/{query_id}`."""
+        self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/v1/tiny-query/queries/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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 run_tiny_query_query(
+        self,
+        query_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,
+    ) -> QueryResult:
+        """Executes a scheduled query's SQL on demand, under the *caller's* own
+        session (same trust boundary as `execute_query_handler`) — not the
+        schedule owner's identity, so this never depends on the owner having
+        granted background execution. Writes to `query_history` like any run
+        (visible in the run-history detail view, output included) but never
+        updates the schedule's own tracked health."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/queries/{query_id}/run",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_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, QueryResult)
+
+    def retrieve_tiny_query_result(
+        self,
+        query_id: UUID,
+        *,
+        offset: int | None = None,
+        limit: 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,
+    ) -> ResultsPage:
+        """`GET /api/v1/tiny-query/results/{query_id}`.
+
+        :param offset: Row offset (default 0)
+        :param limit: Number of rows (default 500)"""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/results/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "offset": offset,
+                        "limit": limit,
+                    },
+                ),
+                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, ResultsPage)
+
+    def create_tiny_query_run(
+        self,
+        *,
+        data_dock_id: UUID,
+        sql: str,
+        limit: int | None | Unset = UNSET,
+        query_id: UUID | None | Unset = UNSET,
+        timeout_seconds: 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,
+    ) -> QueryRun:
+        """Start a query run
+
+        Answers at once with the run's id; poll `GET /api/v1/tiny-query/runs/{query_id}`
+        for its outcome. Takes the same body as `POST /api/v1/tiny-query/execute`.
+
+        :param query_id: Id for the run's history entry, chosen by the caller so it can cancel the run while it executes. Generated server-side when absent.
+        :param timeout_seconds: Seconds before the statement is cancelled. Must sit inside the range `GET /api/v1/harbors/{harbor_id}/tiny-query/limits` returns; omitted, the server default applies."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/v1/tiny-query/runs",
+                json_body=to_json_value(
+                    ExecuteRequest(
+                        data_dock_id=data_dock_id,
+                        limit=limit,
+                        query_id=query_id,
+                        sql=sql,
+                        timeout_seconds=timeout_seconds,
+                    ),
+                    ExecuteRequest,
+                ),
+                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, QueryRun)
+
+    def retrieve_tiny_query_run(
+        self,
+        query_id: UUID,
+        *,
+        wait_seconds: 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,
+    ) -> QueryRun:
+        """Poll a query run
+
+        Waits up to `wait_seconds` for the run to end, then answers where it stands:
+        `running`, `completed` with the first page of rows, or `failed` with the
+        status and message `POST /api/v1/tiny-query/execute` would have returned.
+
+        :param wait_seconds: Seconds to wait for the run to finish before answering `running` (0 to 30, default 0)."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/runs/{query_id}",
+                path_params={
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "wait_seconds": wait_seconds,
+                    },
+                ),
+                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, QueryRun)
+
+    def retrieve_tiny_query_schema(
+        self,
+        data_dock_id: UUID,
+        *,
+        refresh: 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,
+    ) -> TrinoMetadata:
+        """`GET /api/v1/tiny-query/schema/{data_dock_id}`.
+
+        :param refresh: Re-introspect the cluster instead of serving the cached schema.  This is what the schema browser's refresh button sends. Absent or `false` is the normal path and answers from cache while it is warm."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/tiny-query/schema/{data_dock_id}",
+                path_params={
+                    "data_dock_id": encode_path_param(
+                        "data_dock_id", data_dock_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "refresh": refresh,
+                    },
+                ),
+                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, TrinoMetadata)
+
+
+class PetiteRequeteWithRawResponse:
+    """The methods of :class:`PetiteRequete`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: PetiteRequete) -> None:
+        self.list_harbor_tiny_query_analytics_slow_queries = to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_analytics_slow_queries
+        )
+        self.retrieve_harbor_tiny_query_analytics_summary = to_raw_response_wrapper(
+            resource.retrieve_harbor_tiny_query_analytics_summary
+        )
+        self.list_harbor_tiny_query_analytics_trends = to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_analytics_trends
+        )
+        self.list_harbor_tiny_query_history = to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_history
+        )
+        self.list_harbor_tiny_query_limits = to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_limits
+        )
+        self.list_harbor_tiny_query_queries = to_raw_response_wrapper(
+            resource.list_harbor_tiny_query_queries
+        )
+        self.tiny_query_copilot_generate = to_raw_response_wrapper(
+            resource.tiny_query_copilot_generate
+        )
+        self.tiny_query_execute = to_raw_response_wrapper(resource.tiny_query_execute)
+        self.retrieve_tiny_query_history = to_raw_response_wrapper(
+            resource.retrieve_tiny_query_history
+        )
+        self.cancel_tiny_query_history = to_raw_response_wrapper(
+            resource.cancel_tiny_query_history
+        )
+        self.create_tiny_query_query = to_raw_response_wrapper(
+            resource.create_tiny_query_query
+        )
+        self.retrieve_tiny_query_query = to_raw_response_wrapper(
+            resource.retrieve_tiny_query_query
+        )
+        self.update_tiny_query_query = to_raw_response_wrapper(
+            resource.update_tiny_query_query
+        )
+        self.delete_tiny_query_query = to_raw_response_wrapper(
+            resource.delete_tiny_query_query
+        )
+        self.run_tiny_query_query = to_raw_response_wrapper(
+            resource.run_tiny_query_query
+        )
+        self.retrieve_tiny_query_result = to_raw_response_wrapper(
+            resource.retrieve_tiny_query_result
+        )
+        self.create_tiny_query_run = to_raw_response_wrapper(
+            resource.create_tiny_query_run
+        )
+        self.retrieve_tiny_query_run = to_raw_response_wrapper(
+            resource.retrieve_tiny_query_run
+        )
+        self.retrieve_tiny_query_schema = to_raw_response_wrapper(
+            resource.retrieve_tiny_query_schema
+        )