@keboola/api-client 24.0.0 → 27.0.0

package/dist/types-BcaALDYY.d.cts

@@ -0,0 +1,2130 @@
+import { c as OpenapiQueryType, d as OpenapiPathType, O as OpenapiBodyType, b as OpenapiReturnType } from './types-f8dUjMX4.cjs';
+import './appLogs-BbgAJ5I8.cjs';
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+type paths = {
+  '/': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Service metadata
+     * @description Returns the service name, version and a link to this API specification.
+     *     No authentication required.
+     */
+    get: operations['index'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List apps
+     * @description Lists apps for the project, each including `production {desiredNumber, desiredId,
+     *     actualNumber, actualId}` and `undeployedChanges` (whether the production
+     *     deployment's config version differs from the app's current config version — a
+     *     future branch-HEAD comparison is not implemented yet).
+     */
+    get: operations['listApps'];
+    put?: never;
+    /**
+     * Create app
+     * @description Creates the app row plus its AppGroup CR (the product's Kubernetes object); the
+     *     app starts with `production: null` — its URL is reserved but publicly 404s until
+     *     a deployment is promoted. An optional `Idempotency-Key` header makes a retried
+     *     create return the same app instead of a duplicate Storage config, DB row, and
+     *     App CRD — `201` only on the request that actually created it, `200` on every
+     *     replay, so the status code alone tells a caller which happened without diffing
+     *     the body. A retry with no `Idempotency-Key` is always a genuine create (`201`):
+     *     nothing links it to the earlier request.
+     *
+     *     The Storage config this creates has no app content and only the platform's
+     *     default auth (`authorization.app_proxy` requiring a password nobody has set
+     *     yet, so the URL stays unopenable) — this endpoint reserves the app and its
+     *     config address, nothing more. Set `parameters` (what the app runs) and
+     *     `authorization.app_proxy` (who can open it) via the Storage API, on the config
+     *     named by the response's `componentId`/`branchId`/`configId`, before deploying.
+     */
+    post: operations['createApp'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get app detail
+     * @description Same shape as the list entry, incl. `production {desiredNumber, desiredId,
+     *     actualNumber, actualId}` and `undeployedChanges`.
+     */
+    get: operations['getApp'];
+    put?: never;
+    post?: never;
+    /**
+     * Delete app
+     * @description Deletes the AppGroup CR, cascading to every deployment, Secret and pod owned by
+     *     it; rows are soft-deleted.
+     */
+    delete: operations['deleteApp'];
+    options?: never;
+    head?: never;
+    /**
+     * Update app settings
+     * @description Updates plain product settings. Per the `/v2` design rule (see API description),
+     *     operations with side effects beyond a plain attribute write — promote, unpublish,
+     *     suspend, resume — are separate action-verb endpoints, not part of this `PATCH`.
+     *
+     *     No patchable field exists yet: `name` and `description` are create-only (see
+     *     `AppCreateRequest`) and live in the app's Storage configuration, not on the App
+     *     row, so there is nothing here to rename them into. Sending either is rejected as
+     *     an unknown field (`422`), not silently accepted — the only currently valid body is
+     *     `{}`. Additional fields will land here as the `/v2` surface grows.
+     */
+    patch: operations['patchApp'];
+    trace?: never;
+  };
+  '/apps/{appId}/unpublish': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Unpublish app
+     * @description Sets `production` to none — routing is dropped and the app's URL 404s.
+     *     Idempotent: unpublishing an already-unpublished app is a no-op, and so is
+     *     unpublishing an app that has no App CRD at all (never deployed via `/v2`) — from a
+     *     caller's perspective "no App CRD" and "an App CRD with nothing published" are the
+     *     same fact, so both return `204` rather than one of them 409ing.
+     */
+    post: operations['unpublishApp'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/suspend': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Suspend app
+     * @description Sleeps the app's currently serving member now, instead of waiting for the idle
+     *     timer, and disarms wake-on-request: unlike idle auto-suspend, a visitor hitting
+     *     the app's URL afterwards gets a 503 rather than triggering a wakeup. Stays
+     *     suspended until an explicit `resume`. Idempotent: suspending an already-suspended
+     *     app is a no-op; returns `409` if the app has no serving member to suspend.
+     *
+     *     The returned App's `state` becomes `SUSPENDED` — immediately, not on the next
+     *     list/get poll.
+     */
+    post: operations['suspendApp'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/resume': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Resume app
+     * @description Wakes the app's currently serving member now (a warm-up) and re-arms
+     *     wake-on-request, instead of waiting for a visitor to trigger it. Idempotent:
+     *     resuming an already-running app is a no-op; returns `409` if the app has no
+     *     serving member to resume.
+     *
+     *     The returned App's `state` is `STARTING` immediately after resuming an app that
+     *     was actually stopped — the operator has not confirmed the member serving yet at
+     *     the instant this call returns — settling to `RUNNING` once it does.
+     */
+    post: operations['resumeApp'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/activity': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Record app activity
+     * @description Records the timestamp of the app's most recent request — the heartbeat that drives
+     *     idle auto-suspend. Caller-supplied rather than server-stamped, so a caller can batch
+     *     several observed requests into one call and report the actual last-seen time instead
+     *     of the time of the call itself.
+     *
+     *     Callable only by apps-proxy: requires a Manage API application token with the
+     *     `apps:proxy` scope (or an equivalent ServiceAccount token). A Storage API token is
+     *     not accepted here, unlike `PATCH /apps/{appId}`.
+     *
+     *     Idempotent by nature: re-reporting the same or an older timestamp has no side effect
+     *     beyond overwriting the stored value, so no `Idempotency-Key` is needed.
+     */
+    post: operations['recordAppActivity'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/password': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get app password
+     * @description Returns the app's current password for its `password`-type auth provider. `null`
+     *     if none has been minted yet — that happens on the app's first deployment (see
+     *     `POST .../deployments`) or on demand via `POST .../reset-password`. Mirrors
+     *     `/v1`'s `GET /apps/{appId}/password`.
+     */
+    get: operations['getAppPassword'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/reset-password': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Reset app password
+     * @description Mints a new password, replacing any existing one. Not idempotent by design: the
+     *     minted value is unpredictable, so there is no target state a retry could
+     *     re-declare — each call always generates a fresh secret. `400` if the app's config
+     *     has no `password`-type auth provider (nothing to reset). The new password is not
+     *     returned here; fetch it with `GET .../password` immediately after.
+     */
+    post: operations['resetAppPassword'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/runs': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List runs
+     * @description Runs of this app, newest first — app-wide, mirroring `/v1`'s paths. The rollup is
+     *     what you want when something is wrong and you do not yet know which deployment to
+     *     look at; each run carries its own `deploymentId`, and `deploymentId=` narrows the
+     *     list once you do.
+     *
+     *     This is where a failed deployment's cause lives: a run carries `failureReason` and
+     *     `startupLogs`. A deployment reported `FAILED` has an explanation here. One reported
+     *     `PENDING` does not, and that is not an omission — nothing upstream records a cause
+     *     for a container that never executed.
+     *
+     *     `since`/`until` filter on `createdAt`, not `startedAt`: `createdAt` is stamped
+     *     before any compute exists, so it is the only timestamp every run has, including one
+     *     that never started. Filtering on `startedAt` would silently drop exactly the runs
+     *     this endpoint exists to explain. `offset`/`limit` page through the filtered window,
+     *     not the full history — pass `since`/`until` and page until the response is shorter
+     *     than `limit` to know you have the whole window, rather than an arbitrary slice of a
+     *     larger, unbounded one.
+     */
+    get: operations['listRuns'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/runs/{runId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get run detail
+     * @description A single run. Addressed under the app rather than under its deployment, matching `/v1`: a run id is unique on its own, so nesting it would add a path segment carrying no information and force a caller holding an id from the app-wide list to find its deployment first.
+     */
+    get: operations['getRun'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/deployments': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List deployments
+     * @description Full deployment history including retired (`archived: true`) deployments —
+     *     rows outlive their Kubernetes CRs.
+     */
+    get: operations['listDeployments'];
+    put?: never;
+    /**
+     * Create deployment (deploy)
+     * @description Deploys the current config version / branch HEAD as a new immutable deployment.
+     *     `promote: true` by default — deploying also promotes to production unless
+     *     explicitly disabled, in which case the deployment is staged for a later
+     *     promotion and never runs in the meantime. The deployment id is minted synchronously (deterministic
+     *     Kubernetes CR name); the display `number` is allocated from a per-app DB
+     *     sequence, also returned synchronously — an optional `Idempotency-Key` header
+     *     makes a retried deploy return the same row instead of a duplicate: `202` only on
+     *     the request that actually created it, `200` on every replay. A request with no
+     *     `Idempotency-Key` is always a genuine deploy (`202`): nothing links it to an
+     *     earlier request, so it can never be recognised as a replay.
+     *
+     *     Nothing here validates app content: a config with no `parameters` builds
+     *     (`buildState: PREBUILT`) and promotes successfully, then crashes on every run.
+     *     Content lives in the Storage config named by the app's `componentId`/
+     *     `branchId`/`configId`, set via the Storage API — not this request.
+     *
+     *     If the app's config has a `password`-type auth provider and the app has no
+     *     password yet, this call mints one — the same lazy, one-time generation `/v1`
+     *     does when an app with simple auth is first started. Fetch it with
+     *     `GET .../password`; a later deployment never rotates it.
+     */
+    post: operations['createDeployment'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/deployments/{deploymentId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get deployment detail
+     * @description Deployment detail; served from the DB projection. The row is written
+     *     synchronously before the create request returns, so there is no window
+     *     where it is missing (read-your-writes) and no Kubernetes CR fallback.
+     */
+    get: operations['getDeployment'];
+    put?: never;
+    post?: never;
+    /**
+     * Retire deployment
+     * @description **Retires, does not erase** — deletes the member CR and its rendered-config
+     *     Secret immediately (credential hygiene); the row stays in history marked
+     *     `archived: true` and is re-materializable. Deployments have no `PATCH`/`PUT` —
+     *     they are immutable; retirement is a lifecycle transition, not a mutation. `409`
+     *     if this deployment's id is named production by either `production.desiredId` or
+     *     `production.actualId` on the app (promote or roll back to another deployment, or
+     *     unpublish, before retiring it) — a promotion in flight can leave those two
+     *     different for a while, and retiring the one not currently named `desiredId` is
+     *     just as unsafe as retiring the one not currently named `actualId`, since either
+     *     one is still something the app depends on. Idempotent: retiring an already
+     *     `archived` deployment is a no-op. Row hard-deletion happens only via app
+     *     deletion.
+     */
+    delete: operations['deleteDeployment'];
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/deployments/{deploymentId}/promote': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Promote deployment (promote / rollback)
+     * @description Makes this deployment production. Rollback is the same action applied to an
+     *     older deployment — every repoint is audited. Promoting an `archived` deployment
+     *     is allowed (it is re-materialized first).
+     *
+     *     Promotion is **declarative**: this records the intent and returns. The operator
+     *     validates by starting the target deployment — including when the app is
+     *     suspended — and switches the route only once that deployment is serving. A
+     *     target that fails to start never becomes production, and the deployment that was
+     *     already serving keeps serving. There is deliberately no readiness precondition:
+     *     a deployment cannot become ready until it has been asked to be production.
+     *
+     *     Idempotent: re-declaring the deployment that is already production is a no-op.
+     *     Authorized separately from plain app settings.
+     *
+     *     `runState`/`buildState` are not inputs to this decision — a `FAILED`,
+     *     non-archived deployment is promoted exactly like any other non-archived one, by
+     *     whether it is already production, not by why it stopped running. Re-declaring it
+     *     while it is still `production.desired`/`.actual` is the no-op above (`204`).
+     *     Re-declaring it while it is **not** currently production — rolled back away from,
+     *     or never promoted — repoints `production.desired` (`202`) and the operator starts
+     *     it, which from the outside looks like restarting a failed deployment; it is the
+     *     same repoint any not-yet-run deployment gets, not special-cased recovery.
+     */
+    post: operations['promoteDeployment'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/logs/tail': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Tail app logs
+     * @description Streams recent container output of the app's currently serving member — the same
+     *     member `promote` most recently switched traffic to, resolved by the operator from
+     *     the App CRD's serving pointer, not looked up by this service. Mirrors `/v1`'s
+     *     `GET /apps/{appId}/logs/tail`.
+     *
+     *     `since` and `lines` are mutually exclusive filters on where the tail starts;
+     *     omitting both returns the log from its start. `404` if the app has no App CRD at
+     *     all (never deployed via `/v2`); `400` (`apps.appNotRunning`) if it has one but
+     *     nothing is currently serving — both are "there is nothing to tail right now",
+     *     distinguished only by whether the app was ever deployed.
+     */
+    get: operations['tailAppLogs'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/logs/download': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Download app logs
+     * @description The full container output of the app's currently serving member, as a file
+     *     download. Same underlying call as `tail` with neither `since` nor `lines` set —
+     *     no separate retention or size limit applies. Mirrors `/v1`'s
+     *     `GET /apps/{appId}/logs/download`.
+     */
+    get: operations['downloadAppLogs'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/deployments/{deploymentId}/logs/tail': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Tail deployment logs
+     * @description Streams recent container output of this specific deployment's own member — not
+     *     resolved through the app's serving pointer, so this works for a deployment that
+     *     is not (or never was) production, e.g. a candidate that failed to promote. The
+     *     operator streams directly from the deployment's Sandbox CR, which is named after
+     *     the deployment id.
+     *
+     *     `since` and `lines` are mutually exclusive filters on where the tail starts;
+     *     omitting both returns the log from its start. `404` if the app or the deployment
+     *     doesn't exist (or the deployment belongs to a different app); `400`
+     *     (`apps.deploymentNotRunning`) if the deployment exists but has nothing currently
+     *     running to read logs from.
+     */
+    get: operations['tailDeploymentLogs'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/deployments/{deploymentId}/logs/download': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Download deployment logs
+     * @description The full container output of this specific deployment's own member, as a file
+     *     download — same underlying call as `tail` with neither `since` nor `lines` set.
+     *     Not resolved through the app's serving pointer; see `tail` for why that matters.
+     */
+    get: operations['downloadDeploymentLogs'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/git-repo': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get app's Git repository
+     * @description Returns details of the Git repository configured in the app's config
+     *     (`parameters.dataApp.git`). For a managed Git repository both `sshUrl` and
+     *     `httpsUrl` are returned, fetched from the upstream git-service. For an
+     *     externally configured repository only the URL matching the configured protocol
+     *     is returned and the other field is `null`; any embedded credentials are
+     *     stripped.
+     */
+    get: operations['getAppGitRepo'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/git-repo/credentials': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List credentials for the app's managed Git repository
+     * @description Lists non-deleted credentials for the app's managed Git repository. Requires an
+     *     admin Storage API token.
+     */
+    get: operations['listAppGitRepoCredentials'];
+    put?: never;
+    /**
+     * Create credential for the app's managed Git repository
+     * @description Creates a credential (SSH key or HTTP token) for the app's managed Git
+     *     repository. For `http_token` credentials, the response includes a one-time
+     *     `secret` that is never returned again — not on subsequent reads, and not on an
+     *     `Idempotency-Key` replay of this request. Requires an admin Storage API token.
+     *     An optional `Idempotency-Key` header makes a retried create return the existing
+     *     credential instead of a duplicate: `201` only on the request that actually
+     *     created it, `200` on every replay.
+     */
+    post: operations['createAppGitRepoCredential'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/apps/{appId}/git-repo/credentials/{credentialId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get credential detail
+     * @description Returns details of a credential registered with the app's managed Git
+     *     repository. The response never contains the one-time `secret` field. Requires
+     *     an admin Storage API token.
+     */
+    get: operations['getAppGitRepoCredential'];
+    put?: never;
+    post?: never;
+    /**
+     * Revoke and remove a credential
+     * @description Revokes a credential on git-service and soft-deletes the local row. Tolerates
+     *     git-service `404` as already-removed. Requires an admin Storage API token.
+     */
+    delete: operations['deleteAppGitRepoCredential'];
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+};
+type components = {
+  schemas: {
+    /** @description Flat error shape used by every v2 endpoint, matching the v1 convention (e.g. 404 → `{"error": "App \"123\" not found"}`). */
+    ErrorResponse: {
+      error?: string;
+    };
+    App: {
+      id: string;
+      projectId: string;
+      /**
+       * @description Together with `branchId` and `configId`, the Storage address of this app's configuration. The app's **name** and **description** — both set once at creation via `AppCreateRequest` and never editable afterwards — live there and are deliberately not copied onto this response — pointing at where they authoritatively live keeps them correct by construction. Resolve labels for a page of apps with one bulk `listComponentConfigurations` call.
+       *     The app's **content** (`parameters` — what it runs) and **auth** (`authorization.app_proxy` — who can open it) live there too, for the same reason: `/v2` manages apps and deployments, not their configuration. A newly created app's config has neither — no content, and an auth block that requires a password nobody has set — until configured via the Storage API.
+       */
+      componentId: string;
+      /** @description `null` on an app created through `/v1` without a branch. Apps created through `/v2` always resolve the project's default branch at creation, so this is never null for them. */
+      branchId: string | null;
+      configId: string;
+      /** @description The app's current configuration revision. */
+      configVersion: string;
+      /** @enum {string|null} */
+      type?: 'streamlit' | 'python-js' | null;
+      /**
+       * @description Apps created through `/v2` are always `prod`; `dev` occurs only on an app created through `/v1` in dev mode and later adopted.
+       * @enum {string}
+       */
+      mode?: 'prod' | 'dev';
+      /**
+       * Format: url
+       * @description Production URL — stable, unchanged by promote/rollback.
+       *     Mirrored from the operator, which derives the address and publishes it on the App resource; it is not computed here, so it cannot disagree with where the app actually answers. `null` only in the window between creating an app and the first state-sync pass picking the address up, so a freshly created app can report `null` here for a short time.
+       *     Null does not mean "not deployed" — check `production` for that. A URL is reserved from creation and 404s publicly until something is promoted to it.
+       */
+      url: string | null;
+      /**
+       * @description Always present. `null` on all four fields means the app has never been deployed (URL reserved, publicly 404s). Carries both the display number and the id for each of `desired`/`actual` because `promote`/`retire` take a deployment id, not a number — a client holding only the number would have to fetch the deployment list just to find the id it needs to act.
+       *     `desired` and `actual` differ while a promotion is in flight — the operator only moves `actual` once the newly desired deployment reports ready — and this is the supported way to detect that in progress, independently of `state`, which deliberately does not encode it. See `App.state`'s own description.
+       */
+      production: {
+        /** @description Deployment number most recently asked to be production. */
+        desiredNumber?: number | null;
+        /** @description Id of the deployment most recently asked to be production — pass this to `promote`/`retire`, not `desiredNumber`. */
+        desiredId?: string | null;
+        /** @description Deployment number actually serving production traffic right now, per the AppGroup controller's convergence status. */
+        actualNumber?: number | null;
+        /** @description Id of the deployment actually serving production traffic right now — pass this to `promote`/`retire`, not `actualNumber`. */
+        actualId?: string | null;
+      };
+      /** @description Whether the production deployment's config version differs from the app's current config version. A future branch-HEAD comparison is not implemented yet. */
+      undeployedChanges?: boolean;
+      /**
+       * @description Is this app's production currently serving traffic, and if not, why? Answers
+       *     exactly that one question — not "is my code healthy" (that's a deployment's
+       *     own `runState`, which can be `FAILED` while this stays `RUNNING`, because an
+       *     older, still-serving deployment and the newest built one are different
+       *     things at the same instant) and not "will a request wake it" alone (both
+       *     `SLEEPING` and `SUSPENDED` are stopped; only the label tells you which).
+       *
+       *     Deliberately does NOT encode rollout progress — whether a promotion is in
+       *     flight is an orthogonal question to whether production is serving, and this
+       *     field answers only the latter. A promotion can be started from an app that is
+       *     currently `RUNNING` (the old deployment keeps serving throughout) just as much
+       *     as from one that is `SUSPENDED`/`SLEEPING`/`NOT_DEPLOYED` (nothing serves until
+       *     the new one comes up), so "is a promotion in progress" cannot be read off this
+       *     field's value under any reading of it. To detect one, compare `production`'s
+       *     `desiredId`/`desiredNumber` against `actualId`/`actualNumber`: while they
+       *     differ, the deployment named `desired` has been asked for but the one named
+       *     `actual` is still what traffic actually reaches (or nothing is serving yet, if
+       *     `actual` is still `null`). A client that needs both facts — is production
+       *     serving, and is a rollout in progress — must read both `state` and `production`;
+       *     neither can be derived from the other.
+       *
+       *     | Value | Meaning for a caller |
+       *     |---|---|
+       *     | `NOT_DEPLOYED` | No `/v2` deployment has ever been promoted to this app's production. Its URL is reserved and publicly 404s. Also shown for an app that only runs via `/v1` and was never adopted into the deployments model — `production` is `{null, null}` for it too, for the same reason. |
+       *     | `STARTING` | Production is named but not yet confirmed serving — right after a first `promote`/`resume`, during a normal startup, or a promotion in flight where nothing was already serving beforehand (`production.actualId` was `null` going in). |
+       *     | `RUNNING` | Production is named and serving. Normal and healthy — including for the entire duration of a blue/green promotion started from a `RUNNING` app: the old, still-`actual` deployment keeps serving traffic throughout, so this stays `RUNNING` rather than dropping to `STARTING` for the length of the rollout. Compare `production.desiredId`/`actualId` if you need to know whether that rollout is still in progress. |
+       *     | `SLEEPING` | Stopped, but **will** wake on the next request — apps-proxy's wake-on-request path is still armed. This is the NORMAL, expected condition for an idle data app between visits, not an outage; do not alert on it. Produced by idle auto-suspend, which patches only the workload state and deliberately leaves wake-on-request armed. No idle-auto-suspend mechanism exists for a purely `/v2`-created app yet (deferred, not built) — today this is reachable only for a `/v1`-adopted app still picked up by the legacy idle-suspend job, the same way `Deployment.buildState`'s non-`PREBUILT` values are not reachable until builds land. |
+       *     | `SUSPENDED` | Stopped and will **not** wake on the next request — a visitor gets a `503` instead. Produced only by an explicit `POST .../suspend`; cleared only by `POST .../resume`. This is the field this whole enum exists to make distinguishable from `SLEEPING`: before it, both looked identical from the outside, and the only way to tell them apart was `POST .../resume` and inspecting `202` vs `204` — a write used as a read, which could itself wake a sleeping app. |
+       *
+       *     Mirrored from the App CRD (`spec.state`, `spec.autoRestartEnabled`,
+       *     `status.currentState`, `status.production`) by the same background sync that
+       *     mirrors `production`, so reading it costs no extra cluster call — including on
+       *     `GET /apps`, which would otherwise be one cluster round trip per row. The one
+       *     exception: `suspend`/`resume`/`promote`/`unpublish` write this field
+       *     themselves, immediately, in the same call that changes it, so the App they
+       *     return is never one sync cycle stale about its own action.
+       *
+       *     Deliberately not `Stopping`, even though the App CRD's `status.currentState`
+       *     names a fourth value: verified against the operator's product-role
+       *     controller, which never publishes it for a product App — its derivation has
+       *     exactly three branches. Also deliberately not `FAILED` — see above.
+       * @enum {string}
+       */
+      state: 'NOT_DEPLOYED' | 'STARTING' | 'RUNNING' | 'SLEEPING' | 'SUSPENDED';
+    };
+    /** @description Minimal shape — additional fields may be added as the `/v2` surface grows. Deliberately excludes app content and auth: both are Storage API concerns, configured after creation on the config named by the response's `componentId`/`branchId`/`configId` — content via `parameters`, auth via `authorization.app_proxy`. */
+    AppCreateRequest: {
+      /** @description Create-only: stored in the app's Storage configuration (see `App.componentId`) and never copied onto the `App` response. There is no way to rename it after creation — `AppPatchRequest` carries no field for it. */
+      name: string;
+      /**
+       * @description App type. Only data-app types are supported by `/v2/apps` — workspace types (e.g. `snowflake`, `bigquery`) are created via `/apps`, not this endpoint.
+       * @enum {string}
+       */
+      type: 'streamlit' | 'python-js';
+      /** @description Create-only, same as `name` — stored in the app's Storage configuration (see `App.componentId`) and never copied onto the `App` response or editable afterwards. */
+      description?: string | null;
+    };
+    /** @description No patchable field exists yet — `name` and `description` are create-only (see `AppCreateRequest`), so the only currently valid body is `{}`; sending either is rejected as an unknown field (`422`), not silently ignored. Additional fields may be added here as the `/v2` surface grows. Promotion, unpublishing, suspend, and resume are separate action-verb endpoints, not part of this shape. */
+    AppPatchRequest: Record<string, never>;
+    Deployment: {
+      /** @description Deployment id — also the deterministic Kubernetes CR name. */
+      id: string;
+      /** @description Display/sort number, allocated from a per-app DB sequence. */
+      number: number;
+      /** @description Storage config id this deployment was created from. Paired with `configVersion` below because a version number alone cannot be resolved via the Storage API without knowing which config it belongs to — the pairing mirrors `GET /apps/{appId}`, whose own `configId`/`configVersion` describe the app's *current* config rather than what a specific deployment was pinned to. */
+      configId: string;
+      /** @description Storage config version pinned at deploy time. Resolved fresh from Storage on every `POST .../deployments` call, so it can differ from the app's own `configVersion` (which only reflects the config as of app creation). */
+      configVersion: string;
+      /** @description Git commit the deployment's code was built from. Always `null` today: no /v2 app type builds from a git-managed source yet, so nothing ever resolves a commit SHA to attach here. Present as a field now so a future git-backed build path has nowhere else to put it. */
+      gitCommitSha: string | null;
+      /**
+       * @description Backend size, pinned per version at deploy time from the config's `runtime.backend.size` (falling back to `parameters.size`). `null` when the config named no size, or named one that is not a recognised value — in both cases the platform default applies.
+       * @enum {string|null}
+       */
+      size?: 'micro' | 'tiny' | 'small' | 'medium' | 'large' | 'external' | null;
+      /**
+       * @description Does a runnable artifact exist for this deployment?
+       *
+       *     Only `PREBUILT` occurs today, and it is a fact rather than a placeholder: a
+       *     deployment is created with `source.image`, so an image is supplied and the
+       *     platform builds nothing. The remaining values become reachable when builds
+       *     land and a deployment can name a commit or branch instead. `PREBUILT` does
+       *     not become obsolete then — supplying a ready image stays legitimate, so it
+       *     stops being the only value rather than becoming a wrong one.
+       *
+       *     `FAILED` here means no artifact was produced, so the deployment can never
+       *     run. That is a different problem, with a different fix, from a run failure.
+       * @enum {string}
+       */
+      buildState: 'PREBUILT' | 'PENDING' | 'BUILDING' | 'BUILT' | 'FAILED';
+      /**
+       * @description Is there a live workload for this deployment right now, and is it healthy?
+       *
+       *     * `NEVER_RUN` — nothing ever started it. Deployments are created stopped and
+       *       only become running once promoted, so this is the normal state of a staged
+       *       deployment, not a stall.
+       *     * `PENDING` — a run was requested but nothing is executing yet: pulling an
+       *       image, waiting to be scheduled, or unable to be placed at all.
+       *     * `STARTING` — a container is executing but not ready yet.
+       *     * `RUNNING` — up and ready.
+       *     * `STOPPING` / `STOPPED` — shutting down, or stopped having run before.
+       *     * `FAILED` — the workload crashed, could not start, or hit a terminal
+       *       dependency error. `GET /apps/{appId}/runs` carries the cause.
+       *
+       *     **Known limitation.** A promoted deployment blocked by a *platform* failure —
+       *     an image that cannot be pulled, a pod that cannot be scheduled — stays
+       *     `PENDING` indefinitely with no reason attached and no automatic resolution.
+       *     Its container never executes, so nothing records a workload failure. This is
+       *     accepted behaviour, not a transient state to wait out: a `PENDING` that is
+       *     not advancing, with the app's `production.desiredId` naming this deployment's
+       *     `id` while `production.actualId` names another, is what it looks like.
+       *     Production is unaffected — the previously promoted deployment keeps serving.
+       *
+       *     This axis says nothing about whether the deployment is production. That is a
+       *     property of the app's pointer, not of the version, and lives on the app as
+       *     `production.desiredId` / `production.actualId` (plus their `Number` twins).
+       *
+       *     **Deriving a single headline status**, for clients that want one. Apply in
+       *     order, first match wins — recorded here so every client agrees rather than
+       *     inventing its own rule:
+       *
+       *     | condition | headline |
+       *     |---|---|
+       *     | `buildState == FAILED` | build failed |
+       *     | `buildState in (PENDING, BUILDING)` | building |
+       *     | `runState == FAILED` | failed |
+       *     | `runState in (PENDING, STARTING)` | starting |
+       *     | `runState == RUNNING` | running |
+       *     | `runState == STOPPING` | stopping |
+       *     | `runState == STOPPED` | stopped |
+       *     | `runState == NEVER_RUN` | ready — built, idle, promotable |
+       *
+       *     Not published as a field: with `buildState` fixed at `PREBUILT`, it would be
+       *     a pure function of `runState` and so a rename of the field beside it. It
+       *     becomes worth shipping once builds make `buildState` vary.
+       * @enum {string}
+       */
+      runState:
+        | 'NEVER_RUN'
+        | 'PENDING'
+        | 'STARTING'
+        | 'RUNNING'
+        | 'STOPPING'
+        | 'STOPPED'
+        | 'FAILED';
+      /** @description `true` once retired (member CR + rendered-config Secret deleted); the row remains in history and is re-materializable. */
+      archived: boolean;
+      /**
+       * Format: date-time
+       * @description When the deployment was retired; `null` while `archived` is `false`.
+       */
+      archivedAt: string | null;
+      /**
+       * Format: date-time
+       * @description When this deployment row was created (i.e. deployed).
+       */
+      createdAt: string;
+    };
+    /** @description A single execution of a deployment. Shares every field with `/v1`'s run payload except `deploymentId`, which `/v1` does not carry: `/v1` has no concept of deployments, so unlike the rest of this shape it does not travel back there. This is a deliberate, permanent divergence — not drift to "fix" by adding `deploymentId` to `/v1` or by removing it here. */
+    Run: {
+      /** Format: uuid */
+      id: string;
+      appId: string;
+      /** @description The deployment this run belongs to. `null` for a run that belongs to the app itself rather than to a deployment (a `/v1`-style run), which is why it is nullable rather than required-and-present. */
+      deploymentId: string | null;
+      /**
+       * @description Lower-case, unlike the `UPPER_SNAKE` of a deployment's `buildState` and `runState`. That is deliberate, not an oversight: this field is shared with `/v1`'s run payload, and changing the casing on the `/v2` copy alone would fork the two. If it is ever normalised, both surfaces move together.
+       * @enum {string|null}
+       */
+      state?: 'starting' | 'running' | 'failed' | 'finished' | null;
+      /**
+       * Format: date-time
+       * @description When the run was opened — stamped before any compute exists, so `now - createdAt` on a deployment still reported `PENDING` is how long it has failed to start.
+       */
+      createdAt?: string | null;
+      /**
+       * Format: date-time
+       * @description When the run's workload became ready — stamped only once a Pod matching this run reports `Ready`. A run that never got that far keeps `null` here for good, so `startedAt: null` means "no compute ever became healthy", not "no information". It is not a failure signal on its own: a run can end `failed` with `startedAt: null` and still carry a classified `failureReason`.
+       */
+      startedAt?: string | null;
+      /** Format: date-time */
+      stoppedAt?: string | null;
+      startupLogs?: string | null;
+      runtimeSize?: string | null;
+      runtimeBackendType?: string | null;
+      configVersion?: string | null;
+      imageVersion?: string | null;
+      /**
+       * @description Why the run failed, when it did. The cause a failed deployment points at. Set at the moment a cause is attributed and never updated afterwards.
+       *     A cause is recorded whenever one can be attributed, which happens on both sides of the container ever executing: **before compute** — configuration, decryption, storage-token and workspace failures — and **after the container has executed** — a startup probe that never passed, a startup deadline exceeded. So a classified failure says nothing about how far the run got: plenty of them never started at all.
+       *     **The one gap is a container that never executed for a platform reason** — `ImagePullBackOff`, `CreateContainerError`, a Pod that cannot be scheduled. Such a run keeps its `createdAt`, never gets a `startedAt`, and never gets a `failureReason`; it stays open indefinitely rather than being closed as failed. That is deliberate — platform problems are left to recover once the platform issue is fixed — and it is the same gap a deployment stuck at `runState: PENDING` is the visible form of. A run left open this way is never billed: billing needs `startedAt`, and there is no fallback to `createdAt`.
+       *     Absence therefore means "no cause was attributable", not "look again later" — for the platform case nothing further will ever arrive. Runs predating the field are also unclassified.
+       *     Both members are present whenever the object is, but either may be `null`. Branch on `reason`, not on `message`.
+       */
+      failureReason?: {
+        /**
+         * @description Short, stable, machine-readable identifier, intended as a UI i18n key — the member to switch on when headlining a failure. The value set is owned by the operator and is not enumerated here, so a client must keep a default branch for identifiers it does not know.
+         *     Stable, but **coarser than the names suggest**: one identifier is deliberately reused across related causes rather than split, because each value is an i18n key a client has to learn before it can be emitted. Do not infer the precise cause from `reason` alone — `message` carries the actionable detail, and two failures sharing a `reason` need not share a remedy.
+         */
+        reason?: string | null;
+        /** @description Human-readable description of the failure, free of internal resource names and cluster-internal detail. Safe to show verbatim. */
+        message?: string | null;
+      } | null;
+      mode?: string;
+    };
+    DeploymentCreateRequest: {
+      /**
+       * @description If true (the default), this deployment is also promoted to production. Set `false` to stage a release now and promote it later: the deployment is created and its config version pinned immutably, but nothing starts it and it is not reachable — a staged deployment only ever runs once promoted, at which point the operator validates it by starting it and switches the route only if it becomes healthy.
+       * @default true
+       */
+      promote: boolean;
+    };
+    CreateCredentialRequest: {
+      /** @enum {string} */
+      type: 'ssh_key' | 'http_token';
+      /** @description SSH public key. Required iff `type` is `ssh_key`; forbidden otherwise. */
+      publicKey?: string;
+      /**
+       * @description Optional caller-supplied display label.
+       * @default
+       */
+      name: string;
+      /** @enum {string} */
+      permissions: 'readOnly' | 'readWrite';
+    };
+    Credential: {
+      /** Format: uuid */
+      id: string;
+      /** @enum {string} */
+      type: 'ssh_key' | 'http_token';
+      name: string;
+      /** @enum {string} */
+      permissions: 'readOnly' | 'readWrite';
+      ownerAdminId: string;
+      /** Format: date-time */
+      createdAt: string;
+    };
+    CreatedCredential: components['schemas']['Credential'] & {
+      /** @description One-time secret returned only at creation for `http_token` credentials. */
+      secret?: string;
+    };
+    CredentialList: {
+      credentials: components['schemas']['Credential'][];
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+};
+interface operations {
+  index: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Service metadata */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          /**
+           * @example {
+           *       "appName": "sandboxes-service",
+           *       "appVersion": "1.2.3",
+           *       "apiDocs": "http://apps.eu-west-1.aws.keboola.dev/docs/swagger.yaml"
+           *     }
+           */
+          'application/json': {
+            appName?: string;
+            appVersion?: string;
+            /** Format: url */
+            apiDocs?: string;
+          };
+        };
+      };
+    };
+  };
+  listApps: {
+    parameters: {
+      query?: {
+        offset?: number;
+        limit?: number;
+      };
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'][];
+        };
+      };
+    };
+  };
+  createApp: {
+    parameters: {
+      query?: never;
+      header?: {
+        'Idempotency-Key'?: string;
+      };
+      path?: never;
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': components['schemas']['AppCreateRequest'];
+      };
+    };
+    responses: {
+      /** @description OK — an `Idempotency-Key` replay; the app already existed and nothing was created. */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description Created */
+      201: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description Unprocessable Entity */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  getApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  deleteApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  patchApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': components['schemas']['AppPatchRequest'];
+      };
+    };
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  unpublishApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted — production is being unset */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description No Content — already unpublished (with or without an App CRD); no-op */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  suspendApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted — suspend is being applied */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description No Content — already suspended; no-op */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — either the app has no currently serving member to suspend, or the app has no App CRD (it was never deployed via /v2). */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  resumeApp: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted — resume is being applied */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description No Content — already running; no-op */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — either the app has no currently serving member to resume, or the app has no App CRD (it was never deployed via /v2). */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  recordAppActivity: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          /** Format: date-time */
+          lastRequestTimestamp: string;
+        };
+      };
+    };
+    responses: {
+      /** @description No Content — recorded */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Unauthorized */
+      401: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Forbidden */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Unprocessable Entity — missing or malformed `lastRequestTimestamp` */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  getAppPassword: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            password?: string | null;
+          };
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  resetAppPassword: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description Bad Request — the app's config has no `password`-type auth provider. */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  listRuns: {
+    parameters: {
+      query?: {
+        /** @description Restrict to runs of a single deployment. */
+        deploymentId?: string;
+        /** @description Restrict to runs with `createdAt >= since` (RFC 3339 / ISO-8601, e.g. `2026-01-01T00:00:00+00:00`). */
+        since?: string;
+        /** @description Restrict to runs with `createdAt <= until` (RFC 3339 / ISO-8601). */
+        until?: string;
+        /** @description Applies to the window already narrowed by `since`/`until`/`deploymentId`, not to the app's full run history. */
+        offset?: number;
+        limit?: number;
+      };
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Run'][];
+        };
+      };
+      /** @description Bad Request — `since` or `until` is not a parseable RFC 3339 timestamp. */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the token belongs to a different project */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  getRun: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        runId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Run'];
+        };
+      };
+      /** @description Forbidden — the token belongs to a different project */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  listDeployments: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Deployment'][];
+        };
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  createDeployment: {
+    parameters: {
+      query?: never;
+      header?: {
+        'Idempotency-Key'?: string;
+      };
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: {
+      content: {
+        'application/json': components['schemas']['DeploymentCreateRequest'];
+      };
+    };
+    responses: {
+      /** @description OK — an `Idempotency-Key` replay; the deployment already existed and nothing was created. */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Deployment'];
+        };
+      };
+      /** @description Accepted — deployment created. It starts at `buildState: PREBUILT`, `runState: NEVER_RUN`; promoting it is what causes it to run. */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Deployment'];
+        };
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  getDeployment: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        deploymentId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Deployment'];
+        };
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  deleteDeployment: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        deploymentId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted — the member CR and its rendered-config Secret are being deleted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description No Content — already archived; no-op */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — this deployment's id is named production.desiredId or production.actualId on the app. */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  promoteDeployment: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        deploymentId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Accepted — the intent was recorded. The operator validates and switches the route asynchronously; `production.desiredId`/`desiredNumber` and `production.actualId`/`actualNumber` on the app differ until it converges, and the deployment's own `runState` reports a target that failed to start. */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['App'];
+        };
+      };
+      /** @description No Content — already production; no-op */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — the app has no App CRD (it was never deployed via /v2). */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+    };
+  };
+  tailAppLogs: {
+    parameters: {
+      query?: {
+        since?: string;
+        lines?: number;
+      };
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'text/plain': string;
+        };
+      };
+      /** @description Bad Request — the app has an App CRD but no currently serving member (`apps.appNotRunning`). */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  downloadAppLogs: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'text/plain': string;
+        };
+      };
+      /** @description Bad Request — the app has an App CRD but no currently serving member (`apps.appNotRunning`). */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  tailDeploymentLogs: {
+    parameters: {
+      query?: {
+        since?: string;
+        lines?: number;
+      };
+      header?: never;
+      path: {
+        appId: string;
+        deploymentId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'text/plain': string;
+        };
+      };
+      /** @description Bad Request — the deployment exists but has nothing currently running (`apps.deploymentNotRunning`). */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found — the app doesn't exist, or the deployment doesn't exist or belongs to a different app. */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  downloadDeploymentLogs: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        deploymentId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'text/plain': string;
+        };
+      };
+      /** @description Bad Request — the deployment exists but has nothing currently running (`apps.deploymentNotRunning`). */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['ErrorResponse'];
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found — the app doesn't exist, or the deployment doesn't exist or belongs to a different app. */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  getAppGitRepo: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** @description SSH clone URL. `null` for a repository configured over HTTP(S). */
+            sshUrl: string | null;
+            /** @description HTTPS clone URL. `null` for a repository configured over SSH. */
+            httpsUrl: string | null;
+            /** @description Whether the repository is a managed Git repository provisioned by the service. */
+            isManagedGitRepo: boolean;
+          };
+        };
+      };
+      /** @description Forbidden — the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — the app has no Git repository configured. */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  listAppGitRepoCredentials: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['CredentialList'];
+        };
+      };
+      /** @description Forbidden — token lacks admin context, or the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  createAppGitRepoCredential: {
+    parameters: {
+      query?: never;
+      header?: {
+        'Idempotency-Key'?: string;
+      };
+      path: {
+        appId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': components['schemas']['CreateCredentialRequest'];
+      };
+    };
+    responses: {
+      /** @description OK — an `Idempotency-Key` replay; the credential already existed and nothing was created. */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['CreatedCredential'];
+        };
+      };
+      /** @description Created */
+      201: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['CreatedCredential'];
+        };
+      };
+      /** @description Bad Request — invalid payload (wrong type/publicKey combination, missing required fields). */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Forbidden — token lacks admin context, or the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Conflict — the app has no managed Git repository. */
+      409: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  getAppGitRepoCredential: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        credentialId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Credential'];
+        };
+      };
+      /** @description Forbidden — token lacks admin context, or the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found — the app doesn't exist, or the credential doesn't exist or belongs to a different app. */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+  deleteAppGitRepoCredential: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        appId: string;
+        credentialId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description No Content */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Forbidden — token lacks admin context, or the app belongs to a different project than the token's. */
+      403: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+      /** @description Not Found — the app doesn't exist, or the credential doesn't exist or belongs to a different app. */
+      404: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content?: never;
+      };
+    };
+  };
+}
+
+type App = components['schemas']['App'];
+type AppState = App['state'];
+type Deployment = components['schemas']['Deployment'];
+type DeploymentBuildState = Deployment['buildState'];
+type DeploymentRunState = Deployment['runState'];
+type AppRun = components['schemas']['Run'];
+type AppPassword = OpenapiReturnType<paths['/apps/{appId}/password']['get']>;
+type AppGitRepo = OpenapiReturnType<paths['/apps/{appId}/git-repo']['get']>;
+type Credential = components['schemas']['Credential'];
+type CreatedCredential = components['schemas']['CreatedCredential'];
+type CredentialList = components['schemas']['CredentialList'];
+type AppId = OpenapiPathType<paths['/apps/{appId}']['get']>['appId'];
+type DeploymentId = OpenapiPathType<paths['/apps/{appId}/deployments/{deploymentId}']['get']>['deploymentId'];
+type RunId = OpenapiPathType<paths['/apps/{appId}/runs/{runId}']['get']>['runId'];
+type CredentialId = OpenapiPathType<paths['/apps/{appId}/git-repo/credentials/{credentialId}']['get']>['credentialId'];
+type GetAppsQuery = OpenapiQueryType<paths['/apps']['get']>;
+type GetAppRunsQuery = OpenapiQueryType<paths['/apps/{appId}/runs']['get']>;
+type GetLogsTailQuery = OpenapiQueryType<paths['/apps/{appId}/logs/tail']['get']>;
+type CreateAppBody = OpenapiBodyType<paths['/apps']['post']>;
+type CreateDeploymentBody = OpenapiBodyType<paths['/apps/{appId}/deployments']['post']>;
+type CreateCredentialBody = OpenapiBodyType<paths['/apps/{appId}/git-repo/credentials']['post']>;
+
+export type { AppId as A, CreateAppBody as C, DeploymentId as D, GetAppsQuery as G, RunId as R, App as a, GetAppRunsQuery as b, CreateDeploymentBody as c, GetLogsTailQuery as d, components as e, CredentialId as f, CreateCredentialBody as g, AppGitRepo as h, AppPassword as i, AppRun as j, AppState as k, CreatedCredential as l, Credential as m, CredentialList as n, Deployment as o, DeploymentBuildState as p, DeploymentRunState as q };