gen

type App struct {
	// ActiveVersionId Current deployed version; null until the first version is successfully deployed.
	ActiveVersionId *openapi_types.UUID `json:"activeVersionId,omitempty"`

	// AppId Immutable app identifier. Unique among the authenticated organization's live apps: it cannot be changed after creation, and it becomes available again once the app it named reaches `deleted`.
	AppId AppId `json:"appId"`

	// AppName Mutable display name. Must start and end with a non-whitespace character: it is what the console renders and what `sort=name` orders on, and it is not required to be unique. Interior spaces are allowed ("Sentiment Analysis"); leading or trailing whitespace is rejected, because a padded name is indistinguishable from its trimmed form in the console and breaks a name-confirm delete.
	AppName AppName `json:"appName"`

	// Configuration Live worker configuration. Updated via `PATCH /apps/{appId}`.
	Configuration WorkerConfig `json:"configuration"`
	CreatedAt     time.Time    `json:"createdAt"`

	// EffectiveMaxWorkers The worker ceiling the last deploy actually applied, reduced where the organization's credit balance did not back the whole range. The autoscaler cannot grow past it.
	//
	// It describes what was applied, not what is configured now, and the two can differ. It is taken from the `maxWorkers` of the version that was deployed, so deploying an older version applies that version's ceiling; and a later `PATCH` of `configuration.maxWorkers` does not change it until the next deploy. Read it beside `configuration.maxWorkers` rather than as a bound on it.
	//
	// `null` means nothing has been applied yet. It is recalculated on every deploy. A committed credit top-up also recalculates a reduced ceiling and restores the funded range automatically; KEDA then grows the workload from queue demand without a customer redeploy.
	EffectiveMaxWorkers *int32 `json:"effectiveMaxWorkers,omitempty"`

	// EnvironmentVariables Plain-text environment variables for this app. Populated on single-app responses (get, update, stop, resume, delete, deploy, favorite). List of apps returns an empty array to avoid an N+1 per page row — use the `/environment-variables` endpoints to page the set.
	EnvironmentVariables []EnvironmentVariable `json:"environmentVariables"`

	// IsFavorite Whether the authenticated organization has favorited this app. Favorited apps sort ahead of non-favorited apps; toggled via `PUT`/`DELETE` `/v1/apps/{appId}/favorite`.
	IsFavorite bool `json:"isFavorite"`

	// Runtime Observed state for one app at `calculatedAt`. Desired worker scale remains in `configuration`. Worker and GPU counts are always present; traffic, duration, and queue fields are omitted when their backing data is unavailable.
	Runtime AppRuntime `json:"runtime"`

	// Secrets Secrets attached to this app, including any env-var name override. Populated on single-app responses; list of apps returns an empty array to avoid an N+1 — use `/apps/{appId}/secrets` to page the set.
	Secrets   []SecretAttachment `json:"secrets"`
	Status    AppStatus          `json:"status"`
	UpdatedAt time.Time          `json:"updatedAt"`
}

type AppCreate struct {
	// AppId Immutable app identifier. Unique among the authenticated organization's live apps: it cannot be changed after creation, and it becomes available again once the app it named reaches `deleted`.
	AppId AppId `json:"appId"`

	// AppName Mutable display name. Must start and end with a non-whitespace character: it is what the console renders and what `sort=name` orders on, and it is not required to be unique. Interior spaces are allowed ("Sentiment Analysis"); leading or trailing whitespace is rejected, because a padded name is indistinguishable from its trimmed form in the console and breaks a name-confirm delete.
	AppName AppName `json:"appName"`

	// AppSource Write-only. Source for the app's first version; not returned in the App response. Use the `/builds` endpoints to inspect build status.
	// - `code`: the codebase is submitted to the build pipeline; a new image is built and
	//   deployed once ready.
	//
	// - `container`: the submitted zip is built into a wrapper image by the same
	//   pipeline and deployed once ready; the version records the built image, not a
	//   customer-supplied reference.
	//
	// Either way the version is recorded with the app, and the app transitions to `active` once its first version is ready, or to `failed` if the build, validation, or rollout fails.
	AppSource     AppSourceUpsert    `json:"appSource"`
	Configuration WorkerConfigCreate `json:"configuration"`

	// EnvironmentVariables Map with environment variables. Keys are the environment variable names, values are the environment variable values. Use the dedicated `/environment-variables` endpoints to change them after the app exists.
	// Each key must satisfy `EnvironmentVariableName` — POSIX-style, at most 128 characters. OpenAPI 3.0 cannot constrain map keys, so a bad one is rejected by the server rather than by the schema. Keys must also not collide with a secret's injected env var name on the same app (see `attachAppSecret`).
	EnvironmentVariables *map[string]string `json:"environmentVariables,omitempty"`

	// Secrets Existing organization secrets to attach to this app, with an optional env-var name override per entry. This is the app's initial attachment set, so the first rollout carries the values into the worker. The secret must already exist and be `active`; this route does not create one, and an unknown or inactive name returns `404`. Shape matches `POST /apps/{appId}/secrets` so create and attach share one contract. Each injected name must not collide with a key in `environmentVariables` — see `SecretAttach`. Each secret can also be attached to at most 25 deployments total, shared with every other route that attaches it; an entry that would push a secret past that returns `422`.
	Secrets *[]SecretAttach `json:"secrets,omitempty"`

	// Volumes Persistent node-local directories bind-mounted through the checkpointer into the sandboxed application. Use these for downloaded weights and caches that must stay outside the checkpointed root filesystem. Paths must be unique and non-overlapping. The set is frozen into each immutable app version.
	Volumes *[]AppVolume `json:"volumes,omitempty"`
}

type AppErrorStatusClass string

type AppErrorWindow string

type AppEvent struct {
	// AppId Immutable app identifier. Unique among the authenticated organization's live apps: it cannot be changed after creation, and it becomes available again once the app it named reaches `deleted`.
	AppId      AppId               `json:"appId"`
	CreatedAt  *time.Time          `json:"createdAt,omitempty"`
	EndpointId *openapi_types.UUID `json:"endpointId,omitempty"`
	Id         openapi_types.UUID  `json:"id"`

	// Message Human-readable description of what happened. Never blank.
	Message  string              `json:"message"`
	Type     AppEventType        `json:"type"`
	WorkerId *openapi_types.UUID `json:"workerId,omitempty"`
}

type AppEventType string

type AppId = string

type AppName = string

type AppRuntime struct {
	// ActiveWorkers Non-terminal workers (`status` other than `stopped`) on this app. Pending workers count because they still hold capacity.
	ActiveWorkers int64 `json:"activeWorkers"`

	// AverageRequestDuration24h Mean inference request duration in seconds over the last 24 hours (all requests; the duration histogram has no status class). Omitted when metrics cannot be read, when the app had no requests, or when the duration series has no samples for the app in the window.
	AverageRequestDuration24h *float64 `json:"averageRequestDuration24h,omitempty"`

	// CalculatedAt When this runtime snapshot was read from the database.
	CalculatedAt time.Time `json:"calculatedAt"`

	// ErrorRate24h Error ratio (4xx + 5xx over requests) for this app in the last 24 hours, in 0–1. Omitted when metrics cannot be read or when the app had no requests in the window.
	ErrorRate24h *float64 `json:"errorRate24h,omitempty"`

	// ProvisionedGpuCount Sum of `gpuCount` across those workers. A pending worker contributes zero until Kubernetes schedules it onto a node.
	ProvisionedGpuCount int64 `json:"provisionedGpuCount"`

	// QueueDepth Ready plus unacknowledged messages on this app's live inference queue. Omitted when the app is not live or the gauge cannot be read. Zero when the queue is live and empty.
	QueueDepth *int64 `json:"queueDepth,omitempty"`

	// Requests24h Requests served by this app in the last 24 hours. Omitted until available.
	Requests24h *int64 `json:"requests24h,omitempty"`
}

type AppSort string

type AppSourceType string

type AppSourceUpsert struct {
	Source AppSourceUpsert_Source `json:"source"`

	// Type Selects the version creation path. `code` submits customer source code to the Image Build Service; `container` submits a wrapper `Dockerfile` and `container.yaml` for Runware to build into a hosted image.
	Type AppSourceType `json:"type"`
}

type AppSourceUpsert_Source struct {
	// contains filtered or unexported fields
}

type AppStatus string

type AppSummary struct {
	// ActiveApps Apps currently in the `active` status.
	ActiveApps int64 `json:"activeApps"`

	// ActiveWorkers Non-terminal workers (`status` other than `stopped`) across every app in the organization.
	ActiveWorkers int64 `json:"activeWorkers"`

	// CalculatedAt When these metrics were computed.
	CalculatedAt time.Time `json:"calculatedAt"`

	// ErrorRate24h Error ratio (4xx + 5xx over requests) for the last 24 hours, in 0–1. Omitted when metrics cannot be read or when `requests24h` is zero.
	ErrorRate24h *float64 `json:"errorRate24h,omitempty"`

	// ProvisionedGpuCount Sum of `gpuCount` across those same non-terminal workers.
	ProvisionedGpuCount int64 `json:"provisionedGpuCount"`

	// Requests24h Requests served in the last 24 hours across every app. Omitted when metrics cannot be read. Zero when the organization had no traffic.
	Requests24h *int64 `json:"requests24h,omitempty"`

	// SpendToday Provisional pay-as-you-go accrual over the last 24 hours, across every app. Excludes finalization rounding and ledger adjustments. A rolling window rather than a calendar day, so the figure does not reset at a boundary the customer did not choose.
	//
	// What has accrued, not a projection: an app that has just started shows what it has run so far. Time a capacity commitment covered is excluded, because it collects nothing. Omitted when the usage cannot be priced, which a zero would misreport as having run for free.
	SpendToday *MoneyAmount `json:"spendToday,omitempty"`

	// TotalApps All apps in the organization excluding soft-deleted ones.
	TotalApps int64 `json:"totalApps"`
}

type AppUpdate struct {
	// AppName Mutable display name; does not affect app identity or routing. Omit to leave unchanged — an explicit blank or padded value is rejected, not treated as a clear.
	AppName *AppName `json:"appName,omitempty"`

	// AppSource Write-only. New source to build and deploy; not returned in the App response. Use the `/builds` endpoints to inspect build status. Triggers a build (for `code` sources) or validates `container.yaml` then builds (for `container` sources). On accept the resulting version is recorded with a new image tag and rolled through the deploy queue. A builder rejection leaves the app on the previous version and writes no version or build row. After accept, a concurrent secret deactivation or env/secret collision leaves version N+1 recorded and the previous attachment set in place. `activeVersionId` moves only when that rollout completes. Not valid on a `stopped` or `stopping` app — there is nothing to roll the new version onto, and `resume` rolls the pinned one — so supplying it in those statuses returns `409 Conflict`.
	AppSource *AppSourceUpsert `json:"appSource,omitempty"`

	// Configuration Partial worker configuration. Any field present overwrites the live value; omitted fields are left unchanged. Clearing a nullable live field (setting it to null) is not supported — omit the field to leave it unchanged. `fallbackGpuType` is the exception: send an empty string to clear it. `computeType` is create-time only and cannot be patched. Changing `gpuType` affects only newly created workers.
	Configuration *WorkerConfigPatch `json:"configuration,omitempty"`

	// EnvironmentVariables Replaces the app's environment variables. Keys are the variable names, values are the values. A key absent from the map is deleted. A null value omits that key from the new set. The resolved map is snapshotted onto the version this update records, so a deploy applies it. When the copied image is deployable the update pins and rolls, the same as a configuration change.
	EnvironmentVariables *map[string]*string `json:"environmentVariables,omitempty"`

	// Secrets Replaces the app's secret attachments. Same `SecretAttach` shape as create and `POST /apps/{appId}/secrets`. An attachment absent from the array is detached. Injected names must not collide with a plain environment variable on the app. Control-plane record only — secret values do not reach a pod, and the version snapshot carries no secrets — so this field does not roll the workload. An app holds at most 100 environment bindings in total; this array cannot exceed that ceiling on its own. Each individual secret can also be attached to at most 25 deployments total, shared with every other route that attaches it.
	Secrets *[]SecretAttach `json:"secrets,omitempty"`
}

type AppVolume struct {
	// MountPath Absolute path exposed inside the sandboxed application. The path is the volume's stable identity and is mirrored below the app's node-local data directory. Root, duplicate, and overlapping paths are rejected.
	MountPath string `json:"mountPath"`
}

type AttachAppSecretJSONRequestBody = SecretAttach

type AttachAppSecretResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// ApplicationproblemJSON400 the response for an HTTP 400 `application/problem+json` response
	ApplicationproblemJSON400 *BadRequest
	// ApplicationproblemJSON401 the response for an HTTP 401 `application/problem+json` response
	ApplicationproblemJSON401 *Unauthorized
	// ApplicationproblemJSON403 the response for an HTTP 403 `application/problem+json` response
	ApplicationproblemJSON403 *Forbidden
	// ApplicationproblemJSON404 the response for an HTTP 404 `application/problem+json` response
	ApplicationproblemJSON404 *NotFound
	// ApplicationproblemJSON409 the response for an HTTP 409 `application/problem+json` response
	ApplicationproblemJSON409 *Conflict
	// ApplicationproblemJSON422 the response for an HTTP 422 `application/problem+json` response
	ApplicationproblemJSON422 *ValidationError
	// ApplicationproblemJSON503 the response for an HTTP 503 `application/problem+json` response
	ApplicationproblemJSON503 *ServiceUnavailable
}

type BadGateway = ProblemDetails

type BadRequest = ProblemDetails

type Build struct {
	// AppId Immutable app identifier. Unique among the authenticated organization's live apps: it cannot be changed after creation, and it becomes available again once the app it named reaches `deleted`.
	AppId *AppId `json:"appId,omitempty"`

	// CompletedAt When the build reached a terminal status (`ready`/`failed`/`superseded`); null while running or for terminal builds recorded before this was tracked.
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	CreatedAt   *time.Time `json:"createdAt,omitempty"`

	// DurationMs Wall-clock milliseconds from `createdAt` to `completedAt`; null while the build is still running or when no completion time was recorded.
	DurationMs *int64 `json:"durationMs,omitempty"`

	// Error Error message or failure reason; null when the build is still running or succeeded.
	Error *string `json:"error,omitempty"`

	// ExitCode Exit code of the build container: 0 on success, its non-zero code on a build failure. Null while running, on a terminal build whose exit code the builder could no longer report, and when the build container never ran (e.g. an init container such as dockerfile generation failed first).
	ExitCode *int32             `json:"exitCode,omitempty"`
	Id       openapi_types.UUID `json:"id"`

	// LogTail Trailing build log output.
	LogTail *string `json:"logTail,omitempty"`

	// Phases Observed build phases with their timings, recorded once the build is terminal; empty until then. Phase lists differ by `source.type`; never assume a fixed list.
	Phases []BuildPhase `json:"phases"`

	// Source Where a build's source came from: `code` for a customer code submission, `container` for a customer wrapper Dockerfile. `repository` and `revision` are not yet recorded (both sources are zip uploads) and will be added when the platform stores that provenance.
	Source BuildSource `json:"source"`

	// Status Build/validation lifecycle status.
	Status BuildStatus `json:"status"`

	// TriggeredBy Who performed an action — the authenticated user (JWT) or the API key. `kind` says which, so `id` (that actor's UUID) is resolvable to the right thing; `displayName` is its name captured at write time, so it renders as it was even if the user or key is later renamed. Used as `Build.triggeredBy` and `Version.author`.
	TriggeredBy *TriggeredBy `json:"triggeredBy,omitempty"`

	// VersionId The version this build produced. A code build's version is created together with the build, so this is populated in every status; it is null only when no version references the build. A code update carries an image — and so its build — forward onto a new version, so a build may be named by several versions; this is the earliest, the one the build actually produced.
	VersionId *openapi_types.UUID `json:"versionId,omitempty"`

	// VersionNumber Version number of `versionId`; null when `versionId` is null.
	VersionNumber *int32 `json:"versionNumber,omitempty"`
}

type BuildListSummary struct {
	// Total Number of builds recorded for this app.
	Total int64 `json:"total"`

	// Versions Number of versions recorded for this app. Same value as `listVersions` `summary.total`. A config-only update increments this without incrementing `total`.
	Versions int64 `json:"versions"`
}

type BuildPhase struct {
	// CompletedAt Null while the phase is still running.
	CompletedAt *time.Time `json:"completedAt,omitempty"`

	// Name Phase identifier, e.g. `prepare`, `build`, `index`. Deliberately not an enum — new build kinds report new phases without a contract change.
	Name      string            `json:"name"`
	Outcome   BuildPhaseOutcome `json:"outcome"`
	StartedAt time.Time         `json:"startedAt"`
}

type BuildPhaseOutcome string

type BuildSource struct {
	// Type The kind of source that produced this build — `code` or `container`, straight from the build record. Build phases differ by kind, so clients must not assume a fixed phase list. Not modeled as an enum so adding a kind later does not churn the existing source-type constants this API shares.
	Type string `json:"type"`
}

type BuildStatus string

type CatalogEntry struct {
	// Aggregation How each bucket was reduced, e.g. `avg` or `p50`. Carried so a tooltip can say what a point means rather than presenting a bucket reduction as an instant reading.
	Aggregation string `json:"aggregation"`

	// Id The value to pass as `queryId`.
	Id string `json:"id"`

	// Selectors The narrowings this query accepts. Anything else is rejected.
	Selectors []string `json:"selectors"`

	// Series The stable series ids this query returns. Empty when those ids are not known until the request (`apps_request_volume` keys each line on an app id).
	Series []string `json:"series"`

	// Unit The unit of every value in this query's series, e.g. `req/min`.
	Unit string `json:"unit"`

	// Windows The windows this query can answer. A window absent here has no stored series behind it, so a client should not offer it.
	Windows []string `json:"windows"`
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {

	// GetAppSummary App summary metrics for the authenticated organization
	//
	// Aggregate dashboard metrics across all apps owned by the authenticated organization. App and worker tallies are always present. Request and error-rate totals come from the metrics store and are omitted when that hop cannot answer rather than reported as zero. Spend covers a rolling 24 hours and is omitted when the usage cannot be priced.
	//
	// Corresponds with GET /v1/app-summary (the `GetAppSummary` operationId).
	GetAppSummary(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListApps List apps
	//
	// Returns a page of the organization's apps. Filters combine with AND; soft-deleted apps are excluded unless `status=deleted` is requested explicitly. Favorited apps appear before non-favorited apps, with the selected ordering applied within each group.
	//
	// A `cursor` is only valid for the `sort` and filters it was issued under — reusing one across a different ordering or filter set returns `400`.
	//
	// Corresponds with GET /v1/apps (the `ListApps` operationId).
	ListApps(ctx context.Context, params *ListAppsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateAppWithBody Create an app
	//
	// Creates an app together with its worker configuration, environment variables and endpoints, and records version `1` — the immutable description of what to deploy. The app starts in `initializing`, and what happens next depends on the app source type:
	//
	// - `code` source: the codebase is submitted to the build pipeline; once the image is built
	//   and workers become healthy the app transitions to `active` and `activeVersionId`
	//   points at that version. If the build, validation, or rollout fails the app is
	//   marked `failed`.
	//
	// - `container` source: the submitted zip (wrapper `Dockerfile` + `container.yaml`)
	//   goes through the same build pipeline — the wrapper image is built, published and
	//   deployed, so the version carries a `buildId` and the app follows the same
	//   lifecycle as a code source. An invalid `container.yaml` rejects the create
	//   before any build capacity is spent — `400` where the document could not be
	//   parsed at all, `422` where it parsed and broke a rule.
	//
	//
	// `activeVersionId` is null until a rollout completes: a version records what should run, and only a finished deploy says what does.
	//
	// `secrets` attaches organization secrets that already exist. It is the app's initial attachment set, so the first rollout carries their values into the worker. This route does not create a secret — use `POST /v1/secrets` first. A name that is unknown to the organization, or that is not `active`, returns `404`. A name that collides with a key in `environmentVariables`, a repeated name and a set that goes past the binding limit each return `422`. The whole set is checked before any build capacity is spent.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/apps (the `CreateApp` operationId).
	CreateAppWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateApp Create an app
	//
	// Creates an app together with its worker configuration, environment variables and endpoints, and records version `1` — the immutable description of what to deploy. The app starts in `initializing`, and what happens next depends on the app source type:
	//
	// - `code` source: the codebase is submitted to the build pipeline; once the image is built
	//   and workers become healthy the app transitions to `active` and `activeVersionId`
	//   points at that version. If the build, validation, or rollout fails the app is
	//   marked `failed`.
	//
	// - `container` source: the submitted zip (wrapper `Dockerfile` + `container.yaml`)
	//   goes through the same build pipeline — the wrapper image is built, published and
	//   deployed, so the version carries a `buildId` and the app follows the same
	//   lifecycle as a code source. An invalid `container.yaml` rejects the create
	//   before any build capacity is spent — `400` where the document could not be
	//   parsed at all, `422` where it parsed and broke a rule.
	//
	//
	// `activeVersionId` is null until a rollout completes: a version records what should run, and only a finished deploy says what does.
	//
	// `secrets` attaches organization secrets that already exist. It is the app's initial attachment set, so the first rollout carries their values into the worker. This route does not create a secret — use `POST /v1/secrets` first. A name that is unknown to the organization, or that is not `active`, returns `404`. A name that collides with a key in `environmentVariables`, a repeated name and a set that goes past the binding limit each return `422`. The whole set is checked before any build capacity is spent.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/apps (the `CreateApp` operationId).
	CreateApp(ctx context.Context, body CreateAppJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteApp Delete an app
	//
	// Soft delete. Sets `status = deleting` and returns `202` once that intent is persisted. Router removal, canceling in-progress builds, and worker drain (`draining → stopping → stopped`) are performed asynchronously by the deployer/Scaler; `status` becomes `deleted` once all workers stop. All rows are retained for billing finalization, audit, and usage history. Idempotent if the app is already `deleting`.
	//
	// The `appId` is released once `status` reaches `deleted`, and not before: while the app is `deleting` its workload is still being torn down and the name stays taken. A new app created under a released name is a new app and inherits nothing — no version, no build, no event history, and no workers.
	//
	// Corresponds with DELETE /v1/apps/{appId} (the `DeleteApp` operationId).
	DeleteApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetApp Get an app
	//
	// Returns the app the authenticated organization owns under this `appId`. An unknown app and a soft-deleted one both return `404 Not Found`: a deleted app is gone to its owner, and its rows are retained only for billing and audit. To read deleted apps, list them with `status=deleted`.
	//
	// Corresponds with GET /v1/apps/{appId} (the `GetApp` operationId).
	GetApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateAppWithBody Update an app
	//
	// Patches one or more aspects of an app in place. All fields are optional; omitted fields are left unchanged. Valid in any non-`deleted` status, including `stopped` (changes apply on `resume`). Lifecycle transitions use the dedicated `deploy`, `stop`, `resume`, and `delete` operations.
	// A configuration or `environmentVariables` change records a new version with the same image. If that image is deployable, the update pins it as `activeVersionId` and rolls the workload when the app is `active` or `initializing`. A `failed` app is moved to `initializing` and rolled, the same as `POST /deploy`. If the image is not deployable, the version is recorded and `activeVersionId` is left unchanged. If the roll fails, `activeVersionId` is restored and the previous configuration keeps serving. A name-only change records a version and does not pin. A `stopped` or `stopping` app pins the version and rolls it on `resume`. A configuration, `environmentVariables`, or `appSource` change while a create or resume rollout is already in progress returns `409 Conflict`. A name-only or `secrets`-only change does not.
	// `appSource` starts a build and records version N+1 with a new image tag. The deploy queue carries the build-then-deploy tail; `activeVersionId` moves only when that rollout completes. A builder rejection (400 where a container document's parser refused it, 422 where it parsed and broke a rule) leaves the app on its current version and writes no version row and no build row. After the builder accepts, version N+1 is recorded even if a concurrent secret deactivation, an env/secret collision, or the 25-deployment attachment ceiling below prevents this request's env/secrets overlay; in that case the previous environmentVariables and attachment set stay in place and are what the new version snapshots, and the `422` the standalone case below returns does not apply here — the request still succeeds.
	// `environmentVariables` replaces the whole set: a key absent from the map is deleted, and a null value omits that key from the new set. The resolved map is snapshotted onto the new version.
	// `secrets` replaces the whole attachment set. An attachment absent from the array is detached. Injected names must not collide with a plain environment variable on the app; the combined set of plain variables and attachments is capped at 100, and each individual secret can be attached to at most 25 deployments total — an entry that would push a secret past that returns `422`. This is a control-plane record only — secret values do not reach a pod, and the version snapshot carries no secrets — so a secrets-only change does not roll the workload.
	// Endpoints are not a field of this contract: the set belongs to the app source, so it changes only when a new version with a new source builds and deploys.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /v1/apps/{appId} (the `UpdateApp` operationId).
	UpdateAppWithBody(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateApp Update an app
	//
	// Patches one or more aspects of an app in place. All fields are optional; omitted fields are left unchanged. Valid in any non-`deleted` status, including `stopped` (changes apply on `resume`). Lifecycle transitions use the dedicated `deploy`, `stop`, `resume`, and `delete` operations.
	// A configuration or `environmentVariables` change records a new version with the same image. If that image is deployable, the update pins it as `activeVersionId` and rolls the workload when the app is `active` or `initializing`. A `failed` app is moved to `initializing` and rolled, the same as `POST /deploy`. If the image is not deployable, the version is recorded and `activeVersionId` is left unchanged. If the roll fails, `activeVersionId` is restored and the previous configuration keeps serving. A name-only change records a version and does not pin. A `stopped` or `stopping` app pins the version and rolls it on `resume`. A configuration, `environmentVariables`, or `appSource` change while a create or resume rollout is already in progress returns `409 Conflict`. A name-only or `secrets`-only change does not.
	// `appSource` starts a build and records version N+1 with a new image tag. The deploy queue carries the build-then-deploy tail; `activeVersionId` moves only when that rollout completes. A builder rejection (400 where a container document's parser refused it, 422 where it parsed and broke a rule) leaves the app on its current version and writes no version row and no build row. After the builder accepts, version N+1 is recorded even if a concurrent secret deactivation, an env/secret collision, or the 25-deployment attachment ceiling below prevents this request's env/secrets overlay; in that case the previous environmentVariables and attachment set stay in place and are what the new version snapshots, and the `422` the standalone case below returns does not apply here — the request still succeeds.
	// `environmentVariables` replaces the whole set: a key absent from the map is deleted, and a null value omits that key from the new set. The resolved map is snapshotted onto the new version.
	// `secrets` replaces the whole attachment set. An attachment absent from the array is detached. Injected names must not collide with a plain environment variable on the app; the combined set of plain variables and attachments is capped at 100, and each individual secret can be attached to at most 25 deployments total — an entry that would push a secret past that returns `422`. This is a control-plane record only — secret values do not reach a pod, and the version snapshot carries no secrets — so a secrets-only change does not roll the workload.
	// Endpoints are not a field of this contract: the set belongs to the app source, so it changes only when a new version with a new source builds and deploys.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /v1/apps/{appId} (the `UpdateApp` operationId).
	UpdateApp(ctx context.Context, appId AppId, body UpdateAppJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListBuilds List builds
	//
	// Corresponds with GET /v1/apps/{appId}/builds (the `ListBuilds` operationId).
	ListBuilds(ctx context.Context, appId AppId, params *ListBuildsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteBuild Delete or cancel a build
	//
	// Cancels a queued or running build and records it as `superseded`. Deleting a queued or running build ends its current rollout without activating the canceled build, so any previous version keeps serving. A terminal build can be deleted once no live rollout still needs it. Ready builds remain while a version references them.
	//
	// Corresponds with DELETE /v1/apps/{appId}/builds/{buildId} (the `DeleteBuild` operationId).
	DeleteBuild(ctx context.Context, appId AppId, buildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetBuild Get a build
	//
	// Corresponds with GET /v1/apps/{appId}/builds/{buildId} (the `GetBuild` operationId).
	GetBuild(ctx context.Context, appId AppId, buildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeployVersionWithBody Deploy a version
	//
	// Activates a `ready` version by number, setting `activeVersionId` and returning `202` once that intent is persisted. Worker rollout, routing switch, and canceling in-progress builds (`superseded`) are performed asynchronously by the deployer/Scaler. Permitted in any addressable status, including `initializing` and `failed`.
	// To roll back, supply an older `versionNumber` — the operation is identical to a forward deploy. No new version is created and no rebuild happens: the version's existing image is re-applied. Re-deploying the currently active version is permitted and re-applies it.
	// A deploy to a `stopped` or `stopping` app records the version and rolls no workload, because no workers are running: the `202` does not imply a rollout there. The recorded version is the one applied when the app resumes.
	// If the roll of a live app fails, `activeVersionId` is restored to the version that kept serving, so the field keeps naming the running image.
	// **Rollout** (deployer/Scaler): the platform starts workers on the target version, waits for at least one to become healthy, switches task routing to the new version, then drains old-version workers gracefully. Old workers are given a fixed, platform-managed grace period to finish in-flight tasks before being force-terminated. If new workers fail to become healthy, old workers are not drained and the app continues on the previous version.
	// Errors: - Deploy to a `deleting` app returns `409 Conflict` - `versionNumber` not found or not `ready` returns `409 Conflict` - A deploy while a rollout of this app is still in flight returns `409 Conflict`;
	//   one app rolls to one version at a time. Retry once it completes.
	// - Deploy to a non-existent or `deleted` app returns `404 Not Found`
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/apps/{appId}/deploy (the `DeployVersion` operationId).
	DeployVersionWithBody(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeployVersion Deploy a version
	//
	// Activates a `ready` version by number, setting `activeVersionId` and returning `202` once that intent is persisted. Worker rollout, routing switch, and canceling in-progress builds (`superseded`) are performed asynchronously by the deployer/Scaler. Permitted in any addressable status, including `initializing` and `failed`.
	// To roll back, supply an older `versionNumber` — the operation is identical to a forward deploy. No new version is created and no rebuild happens: the version's existing image is re-applied. Re-deploying the currently active version is permitted and re-applies it.
	// A deploy to a `stopped` or `stopping` app records the version and rolls no workload, because no workers are running: the `202` does not imply a rollout there. The recorded version is the one applied when the app resumes.
	// If the roll of a live app fails, `activeVersionId` is restored to the version that kept serving, so the field keeps naming the running image.
	// **Rollout** (deployer/Scaler): the platform starts workers on the target version, waits for at least one to become healthy, switches task routing to the new version, then drains old-version workers gracefully. Old workers are given a fixed, platform-managed grace period to finish in-flight tasks before being force-terminated. If new workers fail to become healthy, old workers are not drained and the app continues on the previous version.
	// Errors: - Deploy to a `deleting` app returns `409 Conflict` - `versionNumber` not found or not `ready` returns `409 Conflict` - A deploy while a rollout of this app is still in flight returns `409 Conflict`;
	//   one app rolls to one version at a time. Retry once it completes.
	// - Deploy to a non-existent or `deleted` app returns `404 Not Found`
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/apps/{appId}/deploy (the `DeployVersion` operationId).
	DeployVersion(ctx context.Context, appId AppId, body DeployVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListEndpoints List endpoints
	//
	// Lists the endpoints of the app's active version. The set is written by the source itself — a code build's introspection, or a container's config document — and is replaced atomically whenever a version activates, so a deploy of a newer version or a rollback to an older one is immediately reflected here. Empty while the app is `initializing`: nothing is routable until its first build is ready and deployed.
	//
	// Each row may include `runtime` (status, req/min, p95, p99) from the latest 5-minute Insights window. Those fields are omitted when metrics cannot be read or the endpoint has no samples; identity always comes from Postgres.
	//
	// Corresponds with GET /v1/apps/{appId}/endpoints (the `ListEndpoints` operationId).
	ListEndpoints(ctx context.Context, appId AppId, params *ListEndpointsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetEndpoint Get an endpoint
	//
	// Returns one live endpoint on the app. `runtime` is the same optional latest-window traffic as `listEndpoints` and is omitted when metrics cannot be read or the endpoint has no samples.
	//
	// Corresponds with GET /v1/apps/{appId}/endpoints/{endpointId} (the `GetEndpoint` operationId).
	GetEndpoint(ctx context.Context, appId AppId, endpointId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListAppEnvironmentVariables List app environment variables
	//
	// Corresponds with GET /v1/apps/{appId}/environment-variables (the `ListAppEnvironmentVariables` operationId).
	ListAppEnvironmentVariables(ctx context.Context, appId AppId, params *ListAppEnvironmentVariablesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteAppEnvironmentVariable Delete an app environment variable
	//
	// Removes one environment variable. A successful delete records a new version carrying the remaining environment set and the same image. If that image is deployable, the delete pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A delete of a key that is present while a rollout of this app is still in flight returns `409 Conflict` and does not remove the value. A name that is not present returns `404` even during that window.
	//
	// Corresponds with DELETE /v1/apps/{appId}/environment-variables/{variableName} (the `DeleteAppEnvironmentVariable` operationId).
	DeleteAppEnvironmentVariable(ctx context.Context, appId AppId, variableName EnvironmentVariableName, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateAppEnvironmentVariableWithBody Update an app environment variable
	//
	// Sets one environment variable, creating it if absent. Names the platform sets on the serving container itself are rejected with `422`, as they are on create.
	//
	// A write that changes the stored value records a new version carrying the live environment set and the same image. If that image is deployable, the write pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A write that leaves the stored value unchanged records no version and does not roll.
	//
	// A write while a rollout of this app is still in flight returns `409 Conflict` and does not store the value. Each changing write is serialized behind that rollout, so setting several variables one at a time is that many sequential rolls with `409`s between them. Replace the whole set in one request with `PATCH /v1/apps/{appId}` `environmentVariables`.
	//
	// An app holds at most 100 environment bindings in total — plain variables plus attached secrets — the same combined ceiling `AppCreate.environmentVariables` declares (create rejects secrets in-request; attach grows the set later). Overwriting an existing variable is always allowed; adding one past the ceiling returns `422`.
	//
	// The name must not collide with a secret already attached to this app (the secret's injected env var name). Secrets and plain env vars share the pod environment; a duplicate would be resolved last-wins by kubelet with no error, so the server rejects it with `422`. The reverse check applies on attach.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PUT /v1/apps/{appId}/environment-variables/{variableName} (the `UpdateAppEnvironmentVariable` operationId).
	UpdateAppEnvironmentVariableWithBody(ctx context.Context, appId AppId, variableName EnvironmentVariableName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateAppEnvironmentVariable Update an app environment variable
	//
	// Sets one environment variable, creating it if absent. Names the platform sets on the serving container itself are rejected with `422`, as they are on create.
	//
	// A write that changes the stored value records a new version carrying the live environment set and the same image. If that image is deployable, the write pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A write that leaves the stored value unchanged records no version and does not roll.
	//
	// A write while a rollout of this app is still in flight returns `409 Conflict` and does not store the value. Each changing write is serialized behind that rollout, so setting several variables one at a time is that many sequential rolls with `409`s between them. Replace the whole set in one request with `PATCH /v1/apps/{appId}` `environmentVariables`.
	//
	// An app holds at most 100 environment bindings in total — plain variables plus attached secrets — the same combined ceiling `AppCreate.environmentVariables` declares (create rejects secrets in-request; attach grows the set later). Overwriting an existing variable is always allowed; adding one past the ceiling returns `422`.
	//
	// The name must not collide with a secret already attached to this app (the secret's injected env var name). Secrets and plain env vars share the pod environment; a duplicate would be resolved last-wins by kubelet with no error, so the server rejects it with `422`. The reverse check applies on attach.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PUT /v1/apps/{appId}/environment-variables/{variableName} (the `UpdateAppEnvironmentVariable` operationId).
	UpdateAppEnvironmentVariable(ctx context.Context, appId AppId, variableName EnvironmentVariableName, body UpdateAppEnvironmentVariableJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListAppErrors List request errors for an app
	//
	// One page of failed inference requests for this app, newest first. Omit `statusClass` for both 4xx and 5xx. The cursor is opaque and is only valid with the same `window` and `statusClass` it was issued under.
	//
	// Corresponds with GET /v1/apps/{appId}/errors (the `ListAppErrors` operationId).
	ListAppErrors(ctx context.Context, appId AppId, params *ListAppErrorsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListAppEvents List app events
	//
	// Corresponds with GET /v1/apps/{appId}/events (the `ListAppEvents` operationId).
	ListAppEvents(ctx context.Context, appId AppId, params *ListAppEventsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UnfavoriteApp Unfavorite an app
	//
	// Removes the organization favorite pin from the app. Idempotent: unfavoriting an app that is not favorited succeeds and returns the app with `isFavorite: false`. Valid in any status including `deleting` and `deleted` — unpinning is not an app lifecycle mutation. Missing apps return `404`.
	//
	// Corresponds with DELETE /v1/apps/{appId}/favorite (the `UnfavoriteApp` operationId).
	UnfavoriteApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FavoriteApp Favorite an app
	//
	// Pins the app as a favorite for the authenticated organization so the console can surface it in a Favorites section. Idempotent: favoriting an already-favorited app succeeds and returns the app with `isFavorite: true`. Apps in `deleting` or `deleted` status cannot be favorited (`404`). Soft-delete clears any existing pin when status becomes `deleting`.
	//
	// Corresponds with PUT /v1/apps/{appId}/favorite (the `FavoriteApp` operationId).
	FavoriteApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StartAsyncTaskWithBody Start a new async task
	//
	// Starts a new async task on `appId`, routing the request body payload to an available worker. The task runs asynchronously and the response is `202`; poll `GET /v1/apps/{appId}/tasks/{taskId}` for completion. Resubmitting a task id is answered with the task it already names rather than starting a second one, so the `202` can carry a task that has already finished: read its `status` instead of assuming `pending`, and note it may name a different `appId`. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-async/{endpointPath} (the `StartAsyncTask` operationId).
	StartAsyncTaskWithBody(ctx context.Context, appId AppId, endpointPath EndpointPath, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StartAsyncTask Start a new async task
	//
	// Starts a new async task on `appId`, routing the request body payload to an available worker. The task runs asynchronously and the response is `202`; poll `GET /v1/apps/{appId}/tasks/{taskId}` for completion. Resubmitting a task id is answered with the task it already names rather than starting a second one, so the `202` can carry a task that has already finished: read its `status` instead of assuming `pending`, and note it may name a different `appId`. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-async/{endpointPath} (the `StartAsyncTask` operationId).
	StartAsyncTask(ctx context.Context, appId AppId, endpointPath EndpointPath, body StartAsyncTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StartSyncTaskWithBody Start a new sync task
	//
	// Starts a new sync task on `appId`, routing the request body payload to an available worker. The request blocks until the task is terminal and returns the result inline (`200`). Resubmitting a task id waits on the task it already names rather than starting a second one, so the `200` carries that task's result and may name a different `appId` — poll it under the one returned. A task that outlives the wait window is **not** a failure: the task is still queued or running, and the response is `202` carrying that task with `status: pending` — the same shape `invoke-async` returns, and it names the owning `appId` on a resubmission just as the `200` does. Poll `GET /v1/apps/{appId}/tasks/{taskId}` for its result. A request the platform cannot attribute to an accepted task fails instead, with no task to poll. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-sync/{endpointPath} (the `StartSyncTask` operationId).
	StartSyncTaskWithBody(ctx context.Context, appId AppId, endpointPath EndpointPath, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StartSyncTask Start a new sync task
	//
	// Starts a new sync task on `appId`, routing the request body payload to an available worker. The request blocks until the task is terminal and returns the result inline (`200`). Resubmitting a task id waits on the task it already names rather than starting a second one, so the `200` carries that task's result and may name a different `appId` — poll it under the one returned. A task that outlives the wait window is **not** a failure: the task is still queued or running, and the response is `202` carrying that task with `status: pending` — the same shape `invoke-async` returns, and it names the owning `appId` on a resubmission just as the `200` does. Poll `GET /v1/apps/{appId}/tasks/{taskId}` for its result. A request the platform cannot attribute to an accepted task fails instead, with no task to poll. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-sync/{endpointPath} (the `StartSyncTask` operationId).
	StartSyncTask(ctx context.Context, appId AppId, endpointPath EndpointPath, body StartSyncTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ResumeApp Resume an app
	//
	// Moves the app to `initializing` and returns `202` once that intent is persisted. The Scaler then starts workers and sets the app to `active`; tasks that remained queued when the app stopped are consumed as workers come online. Precondition: `status = stopped`.
	//
	// Corresponds with POST /v1/apps/{appId}/resume (the `ResumeApp` operationId).
	ResumeApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListAppSecrets List secrets attached to an app
	//
	// Corresponds with GET /v1/apps/{appId}/secrets (the `ListAppSecrets` operationId).
	ListAppSecrets(ctx context.Context, appId AppId, params *ListAppSecretsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AttachAppSecretWithBody Attach a secret to an app
	//
	// Records that an organization secret is attached to an app under a resolved env-var name, and rolls the app's live deployment in place so a running worker picks up the value without waiting for an unrelated deploy. If a rollout is already in progress when this commits, this attach is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live records the attachment only — the next resume reads the attach set fresh. Returns `409` if the secret is already attached, or if another attach would use the same env-var name.
	// The resolved name (`envVarName`, or `secretName` when omitted) must not already exist as a plain environment variable on this app (`deployment_configs.key`). Both sources use the same pod env namespace, so the server rejects the collision with `422` instead of allowing a last-wins override later. The reverse check applies when setting a plain environment variable.
	// An app holds at most 100 environment bindings in total — plain environment variables plus attached secrets — the same combined ceiling as create and the single-key env-var route. Attaching when the app is already at that limit returns `422`.
	// A secret can be attached to at most 25 deployments — rolling every attached deployment is what an update or detach costs, so the ceiling bounds that cost rather than the app side of the binding. Attaching past it returns `422`.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/apps/{appId}/secrets (the `AttachAppSecret` operationId).
	AttachAppSecretWithBody(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AttachAppSecret Attach a secret to an app
	//
	// Records that an organization secret is attached to an app under a resolved env-var name, and rolls the app's live deployment in place so a running worker picks up the value without waiting for an unrelated deploy. If a rollout is already in progress when this commits, this attach is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live records the attachment only — the next resume reads the attach set fresh. Returns `409` if the secret is already attached, or if another attach would use the same env-var name.
	// The resolved name (`envVarName`, or `secretName` when omitted) must not already exist as a plain environment variable on this app (`deployment_configs.key`). Both sources use the same pod env namespace, so the server rejects the collision with `422` instead of allowing a last-wins override later. The reverse check applies when setting a plain environment variable.
	// An app holds at most 100 environment bindings in total — plain environment variables plus attached secrets — the same combined ceiling as create and the single-key env-var route. Attaching when the app is already at that limit returns `422`.
	// A secret can be attached to at most 25 deployments — rolling every attached deployment is what an update or detach costs, so the ceiling bounds that cost rather than the app side of the binding. Attaching past it returns `422`.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/apps/{appId}/secrets (the `AttachAppSecret` operationId).
	AttachAppSecret(ctx context.Context, appId AppId, body AttachAppSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DetachAppSecret Detach a secret from an app
	//
	// Removes the attachment and rolls the app's live deployment in place so a running worker stops receiving the value. If a rollout is already in progress when this commits, this detach is not guaranteed to land on it — the worker stops receiving the value on a later redeploy instead. A deployment that is not live has the removal recorded only — there is nothing to roll until it resumes.
	//
	// Corresponds with DELETE /v1/apps/{appId}/secrets/{secretName} (the `DetachAppSecret` operationId).
	DetachAppSecret(ctx context.Context, appId AppId, secretName SecretName, reqEditors ...RequestEditorFn) (*http.Response, error)

	// StopApp Stop an app
	//
	// Moves the app to `stopping` and returns `202` once that intent is persisted. Scale-to-zero and worker drain are performed asynchronously by the Scaler; `status` becomes `stopped` once all workers drain. In-flight tasks have a fixed, platform-managed grace period to complete; workers that exceed it are force-terminated and their tasks return to the queue per delivery guarantees. New task submissions remain accepted while `stopping`; after the app reaches `stopped`, submissions return `409 Conflict`. Precondition: `status` is `active` or `failed` — a rollout that failed can leave a workload running, and a stop is what takes it away without deleting the app.
	//
	// Corresponds with POST /v1/apps/{appId}/stop (the `StopApp` operationId).
	StopApp(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListTasks List tasks for an app
	//
	// Lists TTL-bounded asynchronous task metadata for this app so a client can recover task ids after an interrupted long-poll or CLI session. Pending includes queued, running and retrying work. Tasks appear only within the configured recovery window. A page can be empty and still have `nextCursor`; continue until it is null. Pending entries are best effort and may disappear if the recovery store restarts; tracked tasks reappear on completion. This is not persisted task history. A task id names one task, so resubmitting one does not add a second entry here. If the app is `stopped`, `deleting`, or `failed`, recovery stays available. Unknown or deleted apps return `404 Not Found`.
	//
	// Corresponds with GET /v1/apps/{appId}/tasks (the `ListTasks` operationId).
	ListTasks(ctx context.Context, appId AppId, params *ListTasksParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetTask Get a task
	//
	// Returns the task's current status, read through the inference transport layer from the shared result store. When `completed`, includes the result `output` and `completedAt`; when `failed`, includes `error`; when `pending`, neither is set. If the app is `stopped`, `deleting`, or `failed`, accepted task results stay readable. A `404 Not Found` means the task cannot currently be verified for this app. Because enqueue-time ownership tracking is best effort, a recently returned task ID can temporarily return `404`; retry it within the normal polling window. Unknown or deleted apps also return `404 Not Found`.
	//
	// Corresponds with GET /v1/apps/{appId}/tasks/{taskId} (the `GetTask` operationId).
	GetTask(ctx context.Context, appId AppId, taskId TaskId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListVersions List versions
	//
	// Corresponds with GET /v1/apps/{appId}/versions (the `ListVersions` operationId).
	ListVersions(ctx context.Context, appId AppId, params *ListVersionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteVersion Delete a version
	//
	// Deletes an unused version while retaining its immutable history. Deleted versions are omitted from version lists, return `404` from version reads, and cannot be deployed. Returns `409` while the app is deleting, or when the version is active, is the app's only remaining version, has a non-stopped worker, or is targeted by a live rollout. Deleting an already deleted version returns `404`. This operation does not remove the version's OCI image.
	//
	// Corresponds with DELETE /v1/apps/{appId}/versions/{versionNumber} (the `DeleteVersion` operationId).
	DeleteVersion(ctx context.Context, appId AppId, versionNumber int32, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetVersion Get a version
	//
	// Corresponds with GET /v1/apps/{appId}/versions/{versionNumber} (the `GetVersion` operationId).
	GetVersion(ctx context.Context, appId AppId, versionNumber int32, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListWorkers List workers
	//
	// Returns a newest-first page of workers observed for the app (including terminal `stopped` rows until purged). Omitted `versionId` scopes the page to the app's `activeVersionId`. An app with no active version therefore answers an empty default page — not that it has no workers, only that none are pinned.         Optional `state`, `status` and `q` narrow the page further; a cursor must be replayed under the same filters it was issued with.
	//
	// Corresponds with GET /v1/apps/{appId}/workers (the `ListWorkers` operationId).
	ListWorkers(ctx context.Context, appId AppId, params *ListWorkersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetWorker Get a worker
	//
	// Returns one worker by id within the app. The id is the Kubernetes pod UID recorded by the reconciler. A worker that belongs to another app (or tenant) is not found.
	//
	// Corresponds with GET /v1/apps/{appId}/workers/{workerId} (the `GetWorker` operationId).
	GetWorker(ctx context.Context, appId AppId, workerId WorkerId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListGpuTypes List supported GPU types and their pricing
	//
	// Returns the global GPU type catalog and pricing. The request requires authentication. Customer principals receive only GPU types with capacity currently offered to customers; a type whose hardware is not yet cleared for customer workloads is omitted. The Runware principal receives the full catalog, including retired types and types not yet offered. Retired entries carry `deletedAt`. Each entry's `pricing` is the price currently in effect.
	//
	// Corresponds with GET /v1/gpu-types (the `ListGpuTypes` operationId).
	ListGpuTypes(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetGpuType Get a GPU type from the catalog
	//
	// Returns an active entry from the global GPU type catalog. Retired entries return `404`. The result is not organization-specific, but the request still requires authentication.
	//
	// Corresponds with GET /v1/gpu-types/{gpuTypeId} (the `GetGpuType` operationId).
	GetGpuType(ctx context.Context, gpuTypeId GpuTypeId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetLogEntries Read one page of a named log query
	//
	// Returns one page of log entries in the requested `sort` order, newest first by default, with opaque cursors for the neighboring pages when they exist. `nextCursor` continues in the `sort` order and `prevCursor` goes back against it, so a client can walk a window in either direction from either end. A cursor is only valid for the `sort` it was issued under; reusing one under the other ordering returns `400`. Query ids and their supported selectors are listed by the insights catalog.
	//
	// Corresponds with GET /v1/logs/queries/{queryId}/entries (the `GetLogEntries` operationId).
	GetLogEntries(ctx context.Context, queryId QueryId, params *GetLogEntriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TailLogEntries Follow a named application log query
	//
	// Streams new application log entries as Server-Sent Events. The stream sends keepalive comments while quiet and ends with an `end` event when its connection lifetime expires or the service shuts down. Clients should reconnect after an `end` event. Use the `runtime_tail` query id; queries that sort or aggregate are rejected because they cannot be followed live.
	//
	// Corresponds with GET /v1/logs/queries/{queryId}/tail (the `TailLogEntries` operationId).
	TailLogEntries(ctx context.Context, queryId QueryId, params *TailLogEntriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListInsightsQueries List the metric and log queries this build can answer
	//
	// The catalog: every named query, its unit and aggregation, the selectors it accepts, the series it returns, and the windows actually backed by stored series.
	//
	// This is the source of query ids. Clients discover ids here rather than carrying a list of their own, and render window tabs from `windows` rather than from the full ladder, so a window whose storage tier has no backing series stays invisible instead of rendering a tab with nothing behind it.
	//
	// Corresponds with GET /v1/metrics/queries (the `ListInsightsQueries` operationId).
	ListInsightsQueries(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetMetricSeries Read one named metric query
	//
	// Returns one chart's data: a single timestamp axis shared by every series, and one dense value array per series aligned to it.
	//
	// Values are dense and positionally aligned to `t`, with an explicit `null` wherever there was no sample. Each timestamp is the END of its bucket, so `window.to` is inclusive and equals the last timestamp in `t`, while `window.from` is exclusive and is one `step_s` before the first.
	//
	// An organization with no metrics yet is answered with the full axis and all-null series rather than an error.
	//
	// `apps_request_volume` returns one series per app: 96 quarter-hour request counts over `window=24h` (`step_s` 900, unit `requests`). Repeat `appId` once per id on the current list page to pad idle apps with all-null series, in request order. A series is named for the live app behind it, so a reused app id reports its own generation's traffic and not the one before it. The same `appId` pad applies to the list-scoped `apps_error_volume` and `apps_request_duration` queries. Other queries reject `appId`. Other windows are not available for these queries.
	//
	// `endpoints_request_volume` is the endpoints-list counterpart: 96 quarter-hour request counts per endpoint over `window=24h` (`step_s` 900, unit `requests`). It requires the public app id. Repeat `endpointId` once per id on the current `listEndpoints` page to pad idle endpoints with all-null series, in request order. Buckets that started before that endpoint row's `createdAt` are null, so a removed-then-readded path does not inherit the previous row's traffic.
	//
	// The same app + `endpointId` pad and `createdAt` clip apply to the list-scoped `endpoints_request_rate`, `endpoints_latency_p95`, `endpoints_latency_p99`, `endpoints_error_volume` and `endpoints_request_count` queries (`window=1h` only, 5-minute step). Those feed `listEndpoints` / `getEndpoint` `runtime` and are omitted from the catalog. Other queries reject `endpointId`. Other windows are not available for these queries.
	//
	// Three queries serve one app's overview, all over `window=24h` at `step_s` 900 and all requiring the public app id: `app_traffic_24h` returns `requests`, `client_errors` (4xx) and `server_errors` (5xx) as request counts; `app_worker_seconds_24h` returns `startup`, `execution` and `idle` as worker-seconds, whose three values in a bucket sum to that bucket's worker time; and `app_cold_starts_24h` returns `cold_starts` as a count. They report counts and totals rather than rates or ratios, so a per-minute figure is a bucket value divided by `step_s / 60` and a 24h ratio is one summed axis over another — summing first and dividing once, because averaging a per-bucket ratio across the axis does not give the 24h ratio. These queries are absent from `listInsightsQueries`: they back the overview rather than the Metrics tab. Other windows are not available for them.
	//
	// Corresponds with GET /v1/metrics/queries/{queryId}/series (the `GetMetricSeries` operationId).
	GetMetricSeries(ctx context.Context, queryId QueryId, params *GetMetricSeriesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListReservedCapacity Report reserved capacity and its use
	//
	// What the authenticated organization has reserved, what it is using of it now, and what overflowed to pay-as-you-go.
	//
	// One entry per commitment scope — one GPU type in one region — because compatible terms add together and cover an allocation between them. The terms that make up the scope are listed with their own dates and quantities.
	//
	// Counts describe recorded billable state at the window end, so a report of a past period describes that period rather than mixing it with the present. A scope with an effective commitment appears even when nothing is using it: an idle reservation is still charged for, and is what the customer most needs to see. Scopes whose terms expired during the period remain with their historical usage and zero committed capacity at the window end.
	//
	// The fixed commitment charge is not here. Serverless meters usage and does not own that charge; the commerce system invoices it from the contract schedule. Usage that cannot be priced returns `500`, with no partial report.
	//
	// Corresponds with GET /v1/reserved-capacity (the `ListReservedCapacity` operationId).
	ListReservedCapacity(ctx context.Context, params *ListReservedCapacityParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListSecrets List secrets
	//
	// Returns secret metadata only; encrypted values are never returned.
	//
	// Corresponds with GET /v1/secrets (the `ListSecrets` operationId).
	ListSecrets(ctx context.Context, params *ListSecretsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSecretWithBody Create a secret
	//
	// Creates an organization-scoped secret. Returns `409` if the name is already in use — including when a secret of that name is `pending_destroy`. List only shows active secrets, so a name can appear free while create still conflicts for as long as that row remains. A `pending_destroy` row is removed, and its name released, by a background sweep once no running worker can still hold the value — there is no deadline on that wait, so a continuously busy app can hold a name for as long as it runs. Recreate-while-deleting may later reuse the pending row with the new value (same name, new ciphertext). An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/secrets (the `CreateSecret` operationId).
	CreateSecretWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSecret Create a secret
	//
	// Creates an organization-scoped secret. Returns `409` if the name is already in use — including when a secret of that name is `pending_destroy`. List only shows active secrets, so a name can appear free while create still conflicts for as long as that row remains. A `pending_destroy` row is removed, and its name released, by a background sweep once no running worker can still hold the value — there is no deadline on that wait, so a continuously busy app can hold a name for as long as it runs. Recreate-while-deleting may later reuse the pending row with the new value (same name, new ciphertext). An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/secrets (the `CreateSecret` operationId).
	CreateSecret(ctx context.Context, body CreateSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteSecret Delete a secret
	//
	// Soft-deletes a secret: marks the row `pending_destroy` and bumps revision. This API does not hard-delete the row. Returns `409` while any app still attaches it — cascade-detach is not performed here; detach each holder with `DELETE .../apps/{id}/secrets/{name}` first, which rolls the deployments it names in place. A background sweep removes the row and releases the name once no running worker can still hold the value, rather than assuming every roll a detach started actually landed — a deployment that was not live when detached has nothing to roll until it resumes, so the sweep is the actual backstop, not the detach. While the row remains `pending_destroy` the name stays reserved, so create may return `409` even though list no longer shows the secret. Retries on an already-pending name are safe when no attachments remain (`204`); they still return `409` while attached.
	//
	// Corresponds with DELETE /v1/secrets/{secretName} (the `DeleteSecret` operationId).
	DeleteSecret(ctx context.Context, secretName SecretName, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateSecretWithBody Update a secret
	//
	// Re-encrypts the value under the same name (no rename). Rolls every live deployment that attaches this secret in place so a running worker picks up the new value. If a rollout is already in progress when this commits, this change is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live picks it up on its next deploy for another reason. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PUT /v1/secrets/{secretName} (the `UpdateSecret` operationId).
	UpdateSecretWithBody(ctx context.Context, secretName SecretName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateSecret Update a secret
	//
	// Re-encrypts the value under the same name (no rename). Rolls every live deployment that attaches this secret in place so a running worker picks up the new value. If a rollout is already in progress when this commits, this change is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live picks it up on its next deploy for another reason. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PUT /v1/secrets/{secretName} (the `UpdateSecret` operationId).
	UpdateSecret(ctx context.Context, secretName SecretName, body UpdateSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSourceUploadWithBody Create a source upload
	//
	// Creates an upload session for a source archive. The session belongs to the authenticated organization and names no app: an upload precedes any app, and the source it publishes may back several. The response contains a short-lived transfer instruction for one exact staging object. Repeating the request with the same idempotency key and declaration while the session is pending and unexpired returns the same upload resource with a refreshed transfer instruction. Replays with a different declaration, or after the session becomes ready, rejected, expired, or deleted, return `409`.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /v1/source-uploads (the `CreateSourceUpload` operationId).
	CreateSourceUploadWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateSourceUpload Create a source upload
	//
	// Creates an upload session for a source archive. The session belongs to the authenticated organization and names no app: an upload precedes any app, and the source it publishes may back several. The response contains a short-lived transfer instruction for one exact staging object. Repeating the request with the same idempotency key and declaration while the session is pending and unexpired returns the same upload resource with a refreshed transfer instruction. Replays with a different declaration, or after the session becomes ready, rejected, expired, or deleted, return `409`.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /v1/source-uploads (the `CreateSourceUpload` operationId).
	CreateSourceUpload(ctx context.Context, body CreateSourceUploadJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteSourceUpload Abort a source upload
	//
	// Aborts an upload that has not published its source and removes its staging object. The session remains as a deleted tombstone so its staging key cannot be reused. Repeating a successful abort is idempotent. A `ready` upload cannot be aborted: the source it published is a resource in its own right, and the request answers `409` with type `source-upload-completed`.
	//
	// Corresponds with DELETE /v1/source-uploads/{uploadId} (the `DeleteSourceUpload` operationId).
	DeleteSourceUpload(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSourceUpload Get a source upload
	//
	// Returns the upload session belonging to the authenticated organization. Once the upload is `ready` the session carries the `sourceId` it published. An upload belonging to another organization returns `404`.
	//
	// Corresponds with GET /v1/source-uploads/{uploadId} (the `GetSourceUpload` operationId).
	GetSourceUpload(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CompleteSourceUpload Complete a source upload
	//
	// Verifies the staging object's length, content type, and SHA-256 digest against the session declaration, applies the archive rules for the source type, and publishes the verified bytes as an immutable source artifact. The first success creates the source and returns the ready session carrying its `sourceId`; a retry returns the same session and the same `sourceId`. A rejected upload keeps its rejection so later retries return the same result.
	//
	// Corresponds with POST /v1/source-uploads/{uploadId}/complete (the `CompleteSourceUpload` operationId).
	CompleteSourceUpload(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetSource Get a source
	//
	// Returns the immutable source artifact a completed upload published: its type and the length and digest upload completion verified. A source is organization-scoped and may be named by any number of apps and versions in that organization; one belonging to another organization returns `404`. There is no list and no delete.
	//
	// Corresponds with GET /v1/sources/{sourceId} (the `GetSource` operationId).
	GetSource(ctx context.Context, sourceId SourceId, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUsageEvents List usage events
	//
	// Append-only billing telemetry; one row per worker state transition.
	//
	// Corresponds with GET /v1/usage (the `ListUsageEvents` operationId).
	ListUsageEvents(ctx context.Context, params *ListUsageEventsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetUsageSummary Summarize usage over a time range
	//
	// GPU time and spend for the authenticated organization, aggregated over a half-open window and grouped by the dimensions asked for.
	//
	// Every figure is derived on read from the immutable usage ledger, the effective-dated price catalog and the organization's capacity commitments. Two consequences follow. The window is bounded, because the read folds every event of every worker in it. And a worker whose recorded life cannot be priced fails the request rather than being left out of the totals, because a total that silently omits usage is a wrong number a caller cannot see is wrong. These failures return `500`, with no partial totals.
	//
	// `paygSpend` is provisional pay-as-you-go accrual, not a settled charge. It excludes whole-second finalization rounding and ledger adjustments. `paygEquivalentValue` prices the same time at the catalog rate whatever covered it, so the difference between them is what a capacity commitment saved. While commitment coverage is not yet applied by settlement, an organization holding a commitment sees a split here that the credit ledger has not yet applied.
	//
	// Corresponds with GET /v1/usage/summary (the `GetUsageSummary` operationId).
	GetUsageSummary(ctx context.Context, params *GetUsageSummaryParams, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// GetAppSummaryWithResponse App summary metrics for the authenticated organization
	//
	// Aggregate dashboard metrics across all apps owned by the authenticated organization. App and worker tallies are always present. Request and error-rate totals come from the metrics store and are omitted when that hop cannot answer rather than reported as zero. Spend covers a rolling 24 hours and is omitted when the usage cannot be priced.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/app-summary (the `GetAppSummary` operationId).
	GetAppSummaryWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAppSummaryResponse, error)

	// ListAppsWithResponse List apps
	//
	// Returns a page of the organization's apps. Filters combine with AND; soft-deleted apps are excluded unless `status=deleted` is requested explicitly. Favorited apps appear before non-favorited apps, with the selected ordering applied within each group.
	//
	// A `cursor` is only valid for the `sort` and filters it was issued under — reusing one across a different ordering or filter set returns `400`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps (the `ListApps` operationId).
	ListAppsWithResponse(ctx context.Context, params *ListAppsParams, reqEditors ...RequestEditorFn) (*ListAppsResponse, error)

	// CreateAppWithBodyWithResponse Create an app
	//
	// Creates an app together with its worker configuration, environment variables and endpoints, and records version `1` — the immutable description of what to deploy. The app starts in `initializing`, and what happens next depends on the app source type:
	//
	// - `code` source: the codebase is submitted to the build pipeline; once the image is built
	//   and workers become healthy the app transitions to `active` and `activeVersionId`
	//   points at that version. If the build, validation, or rollout fails the app is
	//   marked `failed`.
	//
	// - `container` source: the submitted zip (wrapper `Dockerfile` + `container.yaml`)
	//   goes through the same build pipeline — the wrapper image is built, published and
	//   deployed, so the version carries a `buildId` and the app follows the same
	//   lifecycle as a code source. An invalid `container.yaml` rejects the create
	//   before any build capacity is spent — `400` where the document could not be
	//   parsed at all, `422` where it parsed and broke a rule.
	//
	//
	// `activeVersionId` is null until a rollout completes: a version records what should run, and only a finished deploy says what does.
	//
	// `secrets` attaches organization secrets that already exist. It is the app's initial attachment set, so the first rollout carries their values into the worker. This route does not create a secret — use `POST /v1/secrets` first. A name that is unknown to the organization, or that is not `active`, returns `404`. A name that collides with a key in `environmentVariables`, a repeated name and a set that goes past the binding limit each return `422`. The whole set is checked before any build capacity is spent.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps (the `CreateApp` operationId).
	CreateAppWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateAppResponse, error)

	// CreateAppWithResponse Create an app
	//
	// Creates an app together with its worker configuration, environment variables and endpoints, and records version `1` — the immutable description of what to deploy. The app starts in `initializing`, and what happens next depends on the app source type:
	//
	// - `code` source: the codebase is submitted to the build pipeline; once the image is built
	//   and workers become healthy the app transitions to `active` and `activeVersionId`
	//   points at that version. If the build, validation, or rollout fails the app is
	//   marked `failed`.
	//
	// - `container` source: the submitted zip (wrapper `Dockerfile` + `container.yaml`)
	//   goes through the same build pipeline — the wrapper image is built, published and
	//   deployed, so the version carries a `buildId` and the app follows the same
	//   lifecycle as a code source. An invalid `container.yaml` rejects the create
	//   before any build capacity is spent — `400` where the document could not be
	//   parsed at all, `422` where it parsed and broke a rule.
	//
	//
	// `activeVersionId` is null until a rollout completes: a version records what should run, and only a finished deploy says what does.
	//
	// `secrets` attaches organization secrets that already exist. It is the app's initial attachment set, so the first rollout carries their values into the worker. This route does not create a secret — use `POST /v1/secrets` first. A name that is unknown to the organization, or that is not `active`, returns `404`. A name that collides with a key in `environmentVariables`, a repeated name and a set that goes past the binding limit each return `422`. The whole set is checked before any build capacity is spent.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps (the `CreateApp` operationId).
	CreateAppWithResponse(ctx context.Context, body CreateAppJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateAppResponse, error)

	// DeleteAppWithResponse Delete an app
	//
	// Soft delete. Sets `status = deleting` and returns `202` once that intent is persisted. Router removal, canceling in-progress builds, and worker drain (`draining → stopping → stopped`) are performed asynchronously by the deployer/Scaler; `status` becomes `deleted` once all workers stop. All rows are retained for billing finalization, audit, and usage history. Idempotent if the app is already `deleting`.
	//
	// The `appId` is released once `status` reaches `deleted`, and not before: while the app is `deleting` its workload is still being torn down and the name stays taken. A new app created under a released name is a new app and inherits nothing — no version, no build, no event history, and no workers.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId} (the `DeleteApp` operationId).
	DeleteAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*DeleteAppResponse, error)

	// GetAppWithResponse Get an app
	//
	// Returns the app the authenticated organization owns under this `appId`. An unknown app and a soft-deleted one both return `404 Not Found`: a deleted app is gone to its owner, and its rows are retained only for billing and audit. To read deleted apps, list them with `status=deleted`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId} (the `GetApp` operationId).
	GetAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*GetAppResponse, error)

	// UpdateAppWithBodyWithResponse Update an app
	//
	// Patches one or more aspects of an app in place. All fields are optional; omitted fields are left unchanged. Valid in any non-`deleted` status, including `stopped` (changes apply on `resume`). Lifecycle transitions use the dedicated `deploy`, `stop`, `resume`, and `delete` operations.
	// A configuration or `environmentVariables` change records a new version with the same image. If that image is deployable, the update pins it as `activeVersionId` and rolls the workload when the app is `active` or `initializing`. A `failed` app is moved to `initializing` and rolled, the same as `POST /deploy`. If the image is not deployable, the version is recorded and `activeVersionId` is left unchanged. If the roll fails, `activeVersionId` is restored and the previous configuration keeps serving. A name-only change records a version and does not pin. A `stopped` or `stopping` app pins the version and rolls it on `resume`. A configuration, `environmentVariables`, or `appSource` change while a create or resume rollout is already in progress returns `409 Conflict`. A name-only or `secrets`-only change does not.
	// `appSource` starts a build and records version N+1 with a new image tag. The deploy queue carries the build-then-deploy tail; `activeVersionId` moves only when that rollout completes. A builder rejection (400 where a container document's parser refused it, 422 where it parsed and broke a rule) leaves the app on its current version and writes no version row and no build row. After the builder accepts, version N+1 is recorded even if a concurrent secret deactivation, an env/secret collision, or the 25-deployment attachment ceiling below prevents this request's env/secrets overlay; in that case the previous environmentVariables and attachment set stay in place and are what the new version snapshots, and the `422` the standalone case below returns does not apply here — the request still succeeds.
	// `environmentVariables` replaces the whole set: a key absent from the map is deleted, and a null value omits that key from the new set. The resolved map is snapshotted onto the new version.
	// `secrets` replaces the whole attachment set. An attachment absent from the array is detached. Injected names must not collide with a plain environment variable on the app; the combined set of plain variables and attachments is capped at 100, and each individual secret can be attached to at most 25 deployments total — an entry that would push a secret past that returns `422`. This is a control-plane record only — secret values do not reach a pod, and the version snapshot carries no secrets — so a secrets-only change does not roll the workload.
	// Endpoints are not a field of this contract: the set belongs to the app source, so it changes only when a new version with a new source builds and deploys.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /v1/apps/{appId} (the `UpdateApp` operationId).
	UpdateAppWithBodyWithResponse(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateAppResponse, error)

	// UpdateAppWithResponse Update an app
	//
	// Patches one or more aspects of an app in place. All fields are optional; omitted fields are left unchanged. Valid in any non-`deleted` status, including `stopped` (changes apply on `resume`). Lifecycle transitions use the dedicated `deploy`, `stop`, `resume`, and `delete` operations.
	// A configuration or `environmentVariables` change records a new version with the same image. If that image is deployable, the update pins it as `activeVersionId` and rolls the workload when the app is `active` or `initializing`. A `failed` app is moved to `initializing` and rolled, the same as `POST /deploy`. If the image is not deployable, the version is recorded and `activeVersionId` is left unchanged. If the roll fails, `activeVersionId` is restored and the previous configuration keeps serving. A name-only change records a version and does not pin. A `stopped` or `stopping` app pins the version and rolls it on `resume`. A configuration, `environmentVariables`, or `appSource` change while a create or resume rollout is already in progress returns `409 Conflict`. A name-only or `secrets`-only change does not.
	// `appSource` starts a build and records version N+1 with a new image tag. The deploy queue carries the build-then-deploy tail; `activeVersionId` moves only when that rollout completes. A builder rejection (400 where a container document's parser refused it, 422 where it parsed and broke a rule) leaves the app on its current version and writes no version row and no build row. After the builder accepts, version N+1 is recorded even if a concurrent secret deactivation, an env/secret collision, or the 25-deployment attachment ceiling below prevents this request's env/secrets overlay; in that case the previous environmentVariables and attachment set stay in place and are what the new version snapshots, and the `422` the standalone case below returns does not apply here — the request still succeeds.
	// `environmentVariables` replaces the whole set: a key absent from the map is deleted, and a null value omits that key from the new set. The resolved map is snapshotted onto the new version.
	// `secrets` replaces the whole attachment set. An attachment absent from the array is detached. Injected names must not collide with a plain environment variable on the app; the combined set of plain variables and attachments is capped at 100, and each individual secret can be attached to at most 25 deployments total — an entry that would push a secret past that returns `422`. This is a control-plane record only — secret values do not reach a pod, and the version snapshot carries no secrets — so a secrets-only change does not roll the workload.
	// Endpoints are not a field of this contract: the set belongs to the app source, so it changes only when a new version with a new source builds and deploys.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /v1/apps/{appId} (the `UpdateApp` operationId).
	UpdateAppWithResponse(ctx context.Context, appId AppId, body UpdateAppJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateAppResponse, error)

	// ListBuildsWithResponse List builds
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/builds (the `ListBuilds` operationId).
	ListBuildsWithResponse(ctx context.Context, appId AppId, params *ListBuildsParams, reqEditors ...RequestEditorFn) (*ListBuildsResponse, error)

	// DeleteBuildWithResponse Delete or cancel a build
	//
	// Cancels a queued or running build and records it as `superseded`. Deleting a queued or running build ends its current rollout without activating the canceled build, so any previous version keeps serving. A terminal build can be deleted once no live rollout still needs it. Ready builds remain while a version references them.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId}/builds/{buildId} (the `DeleteBuild` operationId).
	DeleteBuildWithResponse(ctx context.Context, appId AppId, buildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteBuildResponse, error)

	// GetBuildWithResponse Get a build
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/builds/{buildId} (the `GetBuild` operationId).
	GetBuildWithResponse(ctx context.Context, appId AppId, buildId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetBuildResponse, error)

	// DeployVersionWithBodyWithResponse Deploy a version
	//
	// Activates a `ready` version by number, setting `activeVersionId` and returning `202` once that intent is persisted. Worker rollout, routing switch, and canceling in-progress builds (`superseded`) are performed asynchronously by the deployer/Scaler. Permitted in any addressable status, including `initializing` and `failed`.
	// To roll back, supply an older `versionNumber` — the operation is identical to a forward deploy. No new version is created and no rebuild happens: the version's existing image is re-applied. Re-deploying the currently active version is permitted and re-applies it.
	// A deploy to a `stopped` or `stopping` app records the version and rolls no workload, because no workers are running: the `202` does not imply a rollout there. The recorded version is the one applied when the app resumes.
	// If the roll of a live app fails, `activeVersionId` is restored to the version that kept serving, so the field keeps naming the running image.
	// **Rollout** (deployer/Scaler): the platform starts workers on the target version, waits for at least one to become healthy, switches task routing to the new version, then drains old-version workers gracefully. Old workers are given a fixed, platform-managed grace period to finish in-flight tasks before being force-terminated. If new workers fail to become healthy, old workers are not drained and the app continues on the previous version.
	// Errors: - Deploy to a `deleting` app returns `409 Conflict` - `versionNumber` not found or not `ready` returns `409 Conflict` - A deploy while a rollout of this app is still in flight returns `409 Conflict`;
	//   one app rolls to one version at a time. Retry once it completes.
	// - Deploy to a non-existent or `deleted` app returns `404 Not Found`
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/deploy (the `DeployVersion` operationId).
	DeployVersionWithBodyWithResponse(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DeployVersionResponse, error)

	// DeployVersionWithResponse Deploy a version
	//
	// Activates a `ready` version by number, setting `activeVersionId` and returning `202` once that intent is persisted. Worker rollout, routing switch, and canceling in-progress builds (`superseded`) are performed asynchronously by the deployer/Scaler. Permitted in any addressable status, including `initializing` and `failed`.
	// To roll back, supply an older `versionNumber` — the operation is identical to a forward deploy. No new version is created and no rebuild happens: the version's existing image is re-applied. Re-deploying the currently active version is permitted and re-applies it.
	// A deploy to a `stopped` or `stopping` app records the version and rolls no workload, because no workers are running: the `202` does not imply a rollout there. The recorded version is the one applied when the app resumes.
	// If the roll of a live app fails, `activeVersionId` is restored to the version that kept serving, so the field keeps naming the running image.
	// **Rollout** (deployer/Scaler): the platform starts workers on the target version, waits for at least one to become healthy, switches task routing to the new version, then drains old-version workers gracefully. Old workers are given a fixed, platform-managed grace period to finish in-flight tasks before being force-terminated. If new workers fail to become healthy, old workers are not drained and the app continues on the previous version.
	// Errors: - Deploy to a `deleting` app returns `409 Conflict` - `versionNumber` not found or not `ready` returns `409 Conflict` - A deploy while a rollout of this app is still in flight returns `409 Conflict`;
	//   one app rolls to one version at a time. Retry once it completes.
	// - Deploy to a non-existent or `deleted` app returns `404 Not Found`
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/deploy (the `DeployVersion` operationId).
	DeployVersionWithResponse(ctx context.Context, appId AppId, body DeployVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*DeployVersionResponse, error)

	// ListEndpointsWithResponse List endpoints
	//
	// Lists the endpoints of the app's active version. The set is written by the source itself — a code build's introspection, or a container's config document — and is replaced atomically whenever a version activates, so a deploy of a newer version or a rollback to an older one is immediately reflected here. Empty while the app is `initializing`: nothing is routable until its first build is ready and deployed.
	//
	// Each row may include `runtime` (status, req/min, p95, p99) from the latest 5-minute Insights window. Those fields are omitted when metrics cannot be read or the endpoint has no samples; identity always comes from Postgres.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/endpoints (the `ListEndpoints` operationId).
	ListEndpointsWithResponse(ctx context.Context, appId AppId, params *ListEndpointsParams, reqEditors ...RequestEditorFn) (*ListEndpointsResponse, error)

	// GetEndpointWithResponse Get an endpoint
	//
	// Returns one live endpoint on the app. `runtime` is the same optional latest-window traffic as `listEndpoints` and is omitted when metrics cannot be read or the endpoint has no samples.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/endpoints/{endpointId} (the `GetEndpoint` operationId).
	GetEndpointWithResponse(ctx context.Context, appId AppId, endpointId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetEndpointResponse, error)

	// ListAppEnvironmentVariablesWithResponse List app environment variables
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/environment-variables (the `ListAppEnvironmentVariables` operationId).
	ListAppEnvironmentVariablesWithResponse(ctx context.Context, appId AppId, params *ListAppEnvironmentVariablesParams, reqEditors ...RequestEditorFn) (*ListAppEnvironmentVariablesResponse, error)

	// DeleteAppEnvironmentVariableWithResponse Delete an app environment variable
	//
	// Removes one environment variable. A successful delete records a new version carrying the remaining environment set and the same image. If that image is deployable, the delete pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A delete of a key that is present while a rollout of this app is still in flight returns `409 Conflict` and does not remove the value. A name that is not present returns `404` even during that window.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId}/environment-variables/{variableName} (the `DeleteAppEnvironmentVariable` operationId).
	DeleteAppEnvironmentVariableWithResponse(ctx context.Context, appId AppId, variableName EnvironmentVariableName, reqEditors ...RequestEditorFn) (*DeleteAppEnvironmentVariableResponse, error)

	// UpdateAppEnvironmentVariableWithBodyWithResponse Update an app environment variable
	//
	// Sets one environment variable, creating it if absent. Names the platform sets on the serving container itself are rejected with `422`, as they are on create.
	//
	// A write that changes the stored value records a new version carrying the live environment set and the same image. If that image is deployable, the write pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A write that leaves the stored value unchanged records no version and does not roll.
	//
	// A write while a rollout of this app is still in flight returns `409 Conflict` and does not store the value. Each changing write is serialized behind that rollout, so setting several variables one at a time is that many sequential rolls with `409`s between them. Replace the whole set in one request with `PATCH /v1/apps/{appId}` `environmentVariables`.
	//
	// An app holds at most 100 environment bindings in total — plain variables plus attached secrets — the same combined ceiling `AppCreate.environmentVariables` declares (create rejects secrets in-request; attach grows the set later). Overwriting an existing variable is always allowed; adding one past the ceiling returns `422`.
	//
	// The name must not collide with a secret already attached to this app (the secret's injected env var name). Secrets and plain env vars share the pod environment; a duplicate would be resolved last-wins by kubelet with no error, so the server rejects it with `422`. The reverse check applies on attach.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/apps/{appId}/environment-variables/{variableName} (the `UpdateAppEnvironmentVariable` operationId).
	UpdateAppEnvironmentVariableWithBodyWithResponse(ctx context.Context, appId AppId, variableName EnvironmentVariableName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateAppEnvironmentVariableResponse, error)

	// UpdateAppEnvironmentVariableWithResponse Update an app environment variable
	//
	// Sets one environment variable, creating it if absent. Names the platform sets on the serving container itself are rejected with `422`, as they are on create.
	//
	// A write that changes the stored value records a new version carrying the live environment set and the same image. If that image is deployable, the write pins it as `activeVersionId` and rolls the workload when the app can take one (`active`, `initializing`, or `failed` which becomes `initializing`). A `stopped` or `stopping` app pins the version and rolls it on `resume`. A write that leaves the stored value unchanged records no version and does not roll.
	//
	// A write while a rollout of this app is still in flight returns `409 Conflict` and does not store the value. Each changing write is serialized behind that rollout, so setting several variables one at a time is that many sequential rolls with `409`s between them. Replace the whole set in one request with `PATCH /v1/apps/{appId}` `environmentVariables`.
	//
	// An app holds at most 100 environment bindings in total — plain variables plus attached secrets — the same combined ceiling `AppCreate.environmentVariables` declares (create rejects secrets in-request; attach grows the set later). Overwriting an existing variable is always allowed; adding one past the ceiling returns `422`.
	//
	// The name must not collide with a secret already attached to this app (the secret's injected env var name). Secrets and plain env vars share the pod environment; a duplicate would be resolved last-wins by kubelet with no error, so the server rejects it with `422`. The reverse check applies on attach.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/apps/{appId}/environment-variables/{variableName} (the `UpdateAppEnvironmentVariable` operationId).
	UpdateAppEnvironmentVariableWithResponse(ctx context.Context, appId AppId, variableName EnvironmentVariableName, body UpdateAppEnvironmentVariableJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateAppEnvironmentVariableResponse, error)

	// ListAppErrorsWithResponse List request errors for an app
	//
	// One page of failed inference requests for this app, newest first. Omit `statusClass` for both 4xx and 5xx. The cursor is opaque and is only valid with the same `window` and `statusClass` it was issued under.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/errors (the `ListAppErrors` operationId).
	ListAppErrorsWithResponse(ctx context.Context, appId AppId, params *ListAppErrorsParams, reqEditors ...RequestEditorFn) (*ListAppErrorsResponse, error)

	// ListAppEventsWithResponse List app events
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/events (the `ListAppEvents` operationId).
	ListAppEventsWithResponse(ctx context.Context, appId AppId, params *ListAppEventsParams, reqEditors ...RequestEditorFn) (*ListAppEventsResponse, error)

	// UnfavoriteAppWithResponse Unfavorite an app
	//
	// Removes the organization favorite pin from the app. Idempotent: unfavoriting an app that is not favorited succeeds and returns the app with `isFavorite: false`. Valid in any status including `deleting` and `deleted` — unpinning is not an app lifecycle mutation. Missing apps return `404`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId}/favorite (the `UnfavoriteApp` operationId).
	UnfavoriteAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*UnfavoriteAppResponse, error)

	// FavoriteAppWithResponse Favorite an app
	//
	// Pins the app as a favorite for the authenticated organization so the console can surface it in a Favorites section. Idempotent: favoriting an already-favorited app succeeds and returns the app with `isFavorite: true`. Apps in `deleting` or `deleted` status cannot be favorited (`404`). Soft-delete clears any existing pin when status becomes `deleting`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/apps/{appId}/favorite (the `FavoriteApp` operationId).
	FavoriteAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*FavoriteAppResponse, error)

	// StartAsyncTaskWithBodyWithResponse Start a new async task
	//
	// Starts a new async task on `appId`, routing the request body payload to an available worker. The task runs asynchronously and the response is `202`; poll `GET /v1/apps/{appId}/tasks/{taskId}` for completion. Resubmitting a task id is answered with the task it already names rather than starting a second one, so the `202` can carry a task that has already finished: read its `status` instead of assuming `pending`, and note it may name a different `appId`. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-async/{endpointPath} (the `StartAsyncTask` operationId).
	StartAsyncTaskWithBodyWithResponse(ctx context.Context, appId AppId, endpointPath EndpointPath, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*StartAsyncTaskResponse, error)

	// StartAsyncTaskWithResponse Start a new async task
	//
	// Starts a new async task on `appId`, routing the request body payload to an available worker. The task runs asynchronously and the response is `202`; poll `GET /v1/apps/{appId}/tasks/{taskId}` for completion. Resubmitting a task id is answered with the task it already names rather than starting a second one, so the `202` can carry a task that has already finished: read its `status` instead of assuming `pending`, and note it may name a different `appId`. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-async/{endpointPath} (the `StartAsyncTask` operationId).
	StartAsyncTaskWithResponse(ctx context.Context, appId AppId, endpointPath EndpointPath, body StartAsyncTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*StartAsyncTaskResponse, error)

	// StartSyncTaskWithBodyWithResponse Start a new sync task
	//
	// Starts a new sync task on `appId`, routing the request body payload to an available worker. The request blocks until the task is terminal and returns the result inline (`200`). Resubmitting a task id waits on the task it already names rather than starting a second one, so the `200` carries that task's result and may name a different `appId` — poll it under the one returned. A task that outlives the wait window is **not** a failure: the task is still queued or running, and the response is `202` carrying that task with `status: pending` — the same shape `invoke-async` returns, and it names the owning `appId` on a resubmission just as the `200` does. Poll `GET /v1/apps/{appId}/tasks/{taskId}` for its result. A request the platform cannot attribute to an accepted task fails instead, with no task to poll. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-sync/{endpointPath} (the `StartSyncTask` operationId).
	StartSyncTaskWithBodyWithResponse(ctx context.Context, appId AppId, endpointPath EndpointPath, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*StartSyncTaskResponse, error)

	// StartSyncTaskWithResponse Start a new sync task
	//
	// Starts a new sync task on `appId`, routing the request body payload to an available worker. The request blocks until the task is terminal and returns the result inline (`200`). Resubmitting a task id waits on the task it already names rather than starting a second one, so the `200` carries that task's result and may name a different `appId` — poll it under the one returned. A task that outlives the wait window is **not** a failure: the task is still queued or running, and the response is `202` carrying that task with `status: pending` — the same shape `invoke-async` returns, and it names the owning `appId` on a resubmission just as the `200` does. Poll `GET /v1/apps/{appId}/tasks/{taskId}` for its result. A request the platform cannot attribute to an accepted task fails instead, with no task to poll. Apps in `initializing`, `active`, or `stopping` accept invocation, with two exceptions: an `initializing` app whose first rollout has not produced a version returns `409 Conflict`, and an `active` app the platform has observed to have no workload able to serve returns `503 Service Unavailable` with no task minted. `stopped`, `deleting`, and `failed` return `409 Conflict`; unknown or deleted apps return `404 Not Found`. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden`, distinguishing that from an app that does not exist. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes. Endpoint membership is checked against the active version's endpoint set before the task is accepted: an endpoint the app does not declare returns `404` whose `endpointPath` extension member carries the rejected path, distinguishing it from an unknown app, and the task never enters the queue.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/invoke-sync/{endpointPath} (the `StartSyncTask` operationId).
	StartSyncTaskWithResponse(ctx context.Context, appId AppId, endpointPath EndpointPath, body StartSyncTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*StartSyncTaskResponse, error)

	// ResumeAppWithResponse Resume an app
	//
	// Moves the app to `initializing` and returns `202` once that intent is persisted. The Scaler then starts workers and sets the app to `active`; tasks that remained queued when the app stopped are consumed as workers come online. Precondition: `status = stopped`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/resume (the `ResumeApp` operationId).
	ResumeAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*ResumeAppResponse, error)

	// ListAppSecretsWithResponse List secrets attached to an app
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/secrets (the `ListAppSecrets` operationId).
	ListAppSecretsWithResponse(ctx context.Context, appId AppId, params *ListAppSecretsParams, reqEditors ...RequestEditorFn) (*ListAppSecretsResponse, error)

	// AttachAppSecretWithBodyWithResponse Attach a secret to an app
	//
	// Records that an organization secret is attached to an app under a resolved env-var name, and rolls the app's live deployment in place so a running worker picks up the value without waiting for an unrelated deploy. If a rollout is already in progress when this commits, this attach is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live records the attachment only — the next resume reads the attach set fresh. Returns `409` if the secret is already attached, or if another attach would use the same env-var name.
	// The resolved name (`envVarName`, or `secretName` when omitted) must not already exist as a plain environment variable on this app (`deployment_configs.key`). Both sources use the same pod env namespace, so the server rejects the collision with `422` instead of allowing a last-wins override later. The reverse check applies when setting a plain environment variable.
	// An app holds at most 100 environment bindings in total — plain environment variables plus attached secrets — the same combined ceiling as create and the single-key env-var route. Attaching when the app is already at that limit returns `422`.
	// A secret can be attached to at most 25 deployments — rolling every attached deployment is what an update or detach costs, so the ceiling bounds that cost rather than the app side of the binding. Attaching past it returns `422`.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/secrets (the `AttachAppSecret` operationId).
	AttachAppSecretWithBodyWithResponse(ctx context.Context, appId AppId, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AttachAppSecretResponse, error)

	// AttachAppSecretWithResponse Attach a secret to an app
	//
	// Records that an organization secret is attached to an app under a resolved env-var name, and rolls the app's live deployment in place so a running worker picks up the value without waiting for an unrelated deploy. If a rollout is already in progress when this commits, this attach is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live records the attachment only — the next resume reads the attach set fresh. Returns `409` if the secret is already attached, or if another attach would use the same env-var name.
	// The resolved name (`envVarName`, or `secretName` when omitted) must not already exist as a plain environment variable on this app (`deployment_configs.key`). Both sources use the same pod env namespace, so the server rejects the collision with `422` instead of allowing a last-wins override later. The reverse check applies when setting a plain environment variable.
	// An app holds at most 100 environment bindings in total — plain environment variables plus attached secrets — the same combined ceiling as create and the single-key env-var route. Attaching when the app is already at that limit returns `422`.
	// A secret can be attached to at most 25 deployments — rolling every attached deployment is what an update or detach costs, so the ceiling bounds that cost rather than the app side of the binding. Attaching past it returns `422`.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/secrets (the `AttachAppSecret` operationId).
	AttachAppSecretWithResponse(ctx context.Context, appId AppId, body AttachAppSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*AttachAppSecretResponse, error)

	// DetachAppSecretWithResponse Detach a secret from an app
	//
	// Removes the attachment and rolls the app's live deployment in place so a running worker stops receiving the value. If a rollout is already in progress when this commits, this detach is not guaranteed to land on it — the worker stops receiving the value on a later redeploy instead. A deployment that is not live has the removal recorded only — there is nothing to roll until it resumes.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId}/secrets/{secretName} (the `DetachAppSecret` operationId).
	DetachAppSecretWithResponse(ctx context.Context, appId AppId, secretName SecretName, reqEditors ...RequestEditorFn) (*DetachAppSecretResponse, error)

	// StopAppWithResponse Stop an app
	//
	// Moves the app to `stopping` and returns `202` once that intent is persisted. Scale-to-zero and worker drain are performed asynchronously by the Scaler; `status` becomes `stopped` once all workers drain. In-flight tasks have a fixed, platform-managed grace period to complete; workers that exceed it are force-terminated and their tasks return to the queue per delivery guarantees. New task submissions remain accepted while `stopping`; after the app reaches `stopped`, submissions return `409 Conflict`. Precondition: `status` is `active` or `failed` — a rollout that failed can leave a workload running, and a stop is what takes it away without deleting the app.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/apps/{appId}/stop (the `StopApp` operationId).
	StopAppWithResponse(ctx context.Context, appId AppId, reqEditors ...RequestEditorFn) (*StopAppResponse, error)

	// ListTasksWithResponse List tasks for an app
	//
	// Lists TTL-bounded asynchronous task metadata for this app so a client can recover task ids after an interrupted long-poll or CLI session. Pending includes queued, running and retrying work. Tasks appear only within the configured recovery window. A page can be empty and still have `nextCursor`; continue until it is null. Pending entries are best effort and may disappear if the recovery store restarts; tracked tasks reappear on completion. This is not persisted task history. A task id names one task, so resubmitting one does not add a second entry here. If the app is `stopped`, `deleting`, or `failed`, recovery stays available. Unknown or deleted apps return `404 Not Found`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/tasks (the `ListTasks` operationId).
	ListTasksWithResponse(ctx context.Context, appId AppId, params *ListTasksParams, reqEditors ...RequestEditorFn) (*ListTasksResponse, error)

	// GetTaskWithResponse Get a task
	//
	// Returns the task's current status, read through the inference transport layer from the shared result store. When `completed`, includes the result `output` and `completedAt`; when `failed`, includes `error`; when `pending`, neither is set. If the app is `stopped`, `deleting`, or `failed`, accepted task results stay readable. A `404 Not Found` means the task cannot currently be verified for this app. Because enqueue-time ownership tracking is best effort, a recently returned task ID can temporarily return `404`; retry it within the normal polling window. Unknown or deleted apps also return `404 Not Found`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/tasks/{taskId} (the `GetTask` operationId).
	GetTaskWithResponse(ctx context.Context, appId AppId, taskId TaskId, reqEditors ...RequestEditorFn) (*GetTaskResponse, error)

	// ListVersionsWithResponse List versions
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/versions (the `ListVersions` operationId).
	ListVersionsWithResponse(ctx context.Context, appId AppId, params *ListVersionsParams, reqEditors ...RequestEditorFn) (*ListVersionsResponse, error)

	// DeleteVersionWithResponse Delete a version
	//
	// Deletes an unused version while retaining its immutable history. Deleted versions are omitted from version lists, return `404` from version reads, and cannot be deployed. Returns `409` while the app is deleting, or when the version is active, is the app's only remaining version, has a non-stopped worker, or is targeted by a live rollout. Deleting an already deleted version returns `404`. This operation does not remove the version's OCI image.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/apps/{appId}/versions/{versionNumber} (the `DeleteVersion` operationId).
	DeleteVersionWithResponse(ctx context.Context, appId AppId, versionNumber int32, reqEditors ...RequestEditorFn) (*DeleteVersionResponse, error)

	// GetVersionWithResponse Get a version
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/versions/{versionNumber} (the `GetVersion` operationId).
	GetVersionWithResponse(ctx context.Context, appId AppId, versionNumber int32, reqEditors ...RequestEditorFn) (*GetVersionResponse, error)

	// ListWorkersWithResponse List workers
	//
	// Returns a newest-first page of workers observed for the app (including terminal `stopped` rows until purged). Omitted `versionId` scopes the page to the app's `activeVersionId`. An app with no active version therefore answers an empty default page — not that it has no workers, only that none are pinned.         Optional `state`, `status` and `q` narrow the page further; a cursor must be replayed under the same filters it was issued with.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/workers (the `ListWorkers` operationId).
	ListWorkersWithResponse(ctx context.Context, appId AppId, params *ListWorkersParams, reqEditors ...RequestEditorFn) (*ListWorkersResponse, error)

	// GetWorkerWithResponse Get a worker
	//
	// Returns one worker by id within the app. The id is the Kubernetes pod UID recorded by the reconciler. A worker that belongs to another app (or tenant) is not found.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/apps/{appId}/workers/{workerId} (the `GetWorker` operationId).
	GetWorkerWithResponse(ctx context.Context, appId AppId, workerId WorkerId, reqEditors ...RequestEditorFn) (*GetWorkerResponse, error)

	// ListGpuTypesWithResponse List supported GPU types and their pricing
	//
	// Returns the global GPU type catalog and pricing. The request requires authentication. Customer principals receive only GPU types with capacity currently offered to customers; a type whose hardware is not yet cleared for customer workloads is omitted. The Runware principal receives the full catalog, including retired types and types not yet offered. Retired entries carry `deletedAt`. Each entry's `pricing` is the price currently in effect.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/gpu-types (the `ListGpuTypes` operationId).
	ListGpuTypesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListGpuTypesResponse, error)

	// GetGpuTypeWithResponse Get a GPU type from the catalog
	//
	// Returns an active entry from the global GPU type catalog. Retired entries return `404`. The result is not organization-specific, but the request still requires authentication.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/gpu-types/{gpuTypeId} (the `GetGpuType` operationId).
	GetGpuTypeWithResponse(ctx context.Context, gpuTypeId GpuTypeId, reqEditors ...RequestEditorFn) (*GetGpuTypeResponse, error)

	// GetLogEntriesWithResponse Read one page of a named log query
	//
	// Returns one page of log entries in the requested `sort` order, newest first by default, with opaque cursors for the neighboring pages when they exist. `nextCursor` continues in the `sort` order and `prevCursor` goes back against it, so a client can walk a window in either direction from either end. A cursor is only valid for the `sort` it was issued under; reusing one under the other ordering returns `400`. Query ids and their supported selectors are listed by the insights catalog.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/logs/queries/{queryId}/entries (the `GetLogEntries` operationId).
	GetLogEntriesWithResponse(ctx context.Context, queryId QueryId, params *GetLogEntriesParams, reqEditors ...RequestEditorFn) (*GetLogEntriesResponse, error)

	// TailLogEntriesWithResponse Follow a named application log query
	//
	// Streams new application log entries as Server-Sent Events. The stream sends keepalive comments while quiet and ends with an `end` event when its connection lifetime expires or the service shuts down. Clients should reconnect after an `end` event. Use the `runtime_tail` query id; queries that sort or aggregate are rejected because they cannot be followed live.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/logs/queries/{queryId}/tail (the `TailLogEntries` operationId).
	TailLogEntriesWithResponse(ctx context.Context, queryId QueryId, params *TailLogEntriesParams, reqEditors ...RequestEditorFn) (*TailLogEntriesResponse, error)

	// ListInsightsQueriesWithResponse List the metric and log queries this build can answer
	//
	// The catalog: every named query, its unit and aggregation, the selectors it accepts, the series it returns, and the windows actually backed by stored series.
	//
	// This is the source of query ids. Clients discover ids here rather than carrying a list of their own, and render window tabs from `windows` rather than from the full ladder, so a window whose storage tier has no backing series stays invisible instead of rendering a tab with nothing behind it.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/metrics/queries (the `ListInsightsQueries` operationId).
	ListInsightsQueriesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListInsightsQueriesResponse, error)

	// GetMetricSeriesWithResponse Read one named metric query
	//
	// Returns one chart's data: a single timestamp axis shared by every series, and one dense value array per series aligned to it.
	//
	// Values are dense and positionally aligned to `t`, with an explicit `null` wherever there was no sample. Each timestamp is the END of its bucket, so `window.to` is inclusive and equals the last timestamp in `t`, while `window.from` is exclusive and is one `step_s` before the first.
	//
	// An organization with no metrics yet is answered with the full axis and all-null series rather than an error.
	//
	// `apps_request_volume` returns one series per app: 96 quarter-hour request counts over `window=24h` (`step_s` 900, unit `requests`). Repeat `appId` once per id on the current list page to pad idle apps with all-null series, in request order. A series is named for the live app behind it, so a reused app id reports its own generation's traffic and not the one before it. The same `appId` pad applies to the list-scoped `apps_error_volume` and `apps_request_duration` queries. Other queries reject `appId`. Other windows are not available for these queries.
	//
	// `endpoints_request_volume` is the endpoints-list counterpart: 96 quarter-hour request counts per endpoint over `window=24h` (`step_s` 900, unit `requests`). It requires the public app id. Repeat `endpointId` once per id on the current `listEndpoints` page to pad idle endpoints with all-null series, in request order. Buckets that started before that endpoint row's `createdAt` are null, so a removed-then-readded path does not inherit the previous row's traffic.
	//
	// The same app + `endpointId` pad and `createdAt` clip apply to the list-scoped `endpoints_request_rate`, `endpoints_latency_p95`, `endpoints_latency_p99`, `endpoints_error_volume` and `endpoints_request_count` queries (`window=1h` only, 5-minute step). Those feed `listEndpoints` / `getEndpoint` `runtime` and are omitted from the catalog. Other queries reject `endpointId`. Other windows are not available for these queries.
	//
	// Three queries serve one app's overview, all over `window=24h` at `step_s` 900 and all requiring the public app id: `app_traffic_24h` returns `requests`, `client_errors` (4xx) and `server_errors` (5xx) as request counts; `app_worker_seconds_24h` returns `startup`, `execution` and `idle` as worker-seconds, whose three values in a bucket sum to that bucket's worker time; and `app_cold_starts_24h` returns `cold_starts` as a count. They report counts and totals rather than rates or ratios, so a per-minute figure is a bucket value divided by `step_s / 60` and a 24h ratio is one summed axis over another — summing first and dividing once, because averaging a per-bucket ratio across the axis does not give the 24h ratio. These queries are absent from `listInsightsQueries`: they back the overview rather than the Metrics tab. Other windows are not available for them.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/metrics/queries/{queryId}/series (the `GetMetricSeries` operationId).
	GetMetricSeriesWithResponse(ctx context.Context, queryId QueryId, params *GetMetricSeriesParams, reqEditors ...RequestEditorFn) (*GetMetricSeriesResponse, error)

	// ListReservedCapacityWithResponse Report reserved capacity and its use
	//
	// What the authenticated organization has reserved, what it is using of it now, and what overflowed to pay-as-you-go.
	//
	// One entry per commitment scope — one GPU type in one region — because compatible terms add together and cover an allocation between them. The terms that make up the scope are listed with their own dates and quantities.
	//
	// Counts describe recorded billable state at the window end, so a report of a past period describes that period rather than mixing it with the present. A scope with an effective commitment appears even when nothing is using it: an idle reservation is still charged for, and is what the customer most needs to see. Scopes whose terms expired during the period remain with their historical usage and zero committed capacity at the window end.
	//
	// The fixed commitment charge is not here. Serverless meters usage and does not own that charge; the commerce system invoices it from the contract schedule. Usage that cannot be priced returns `500`, with no partial report.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/reserved-capacity (the `ListReservedCapacity` operationId).
	ListReservedCapacityWithResponse(ctx context.Context, params *ListReservedCapacityParams, reqEditors ...RequestEditorFn) (*ListReservedCapacityResponse, error)

	// ListSecretsWithResponse List secrets
	//
	// Returns secret metadata only; encrypted values are never returned.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/secrets (the `ListSecrets` operationId).
	ListSecretsWithResponse(ctx context.Context, params *ListSecretsParams, reqEditors ...RequestEditorFn) (*ListSecretsResponse, error)

	// CreateSecretWithBodyWithResponse Create a secret
	//
	// Creates an organization-scoped secret. Returns `409` if the name is already in use — including when a secret of that name is `pending_destroy`. List only shows active secrets, so a name can appear free while create still conflicts for as long as that row remains. A `pending_destroy` row is removed, and its name released, by a background sweep once no running worker can still hold the value — there is no deadline on that wait, so a continuously busy app can hold a name for as long as it runs. Recreate-while-deleting may later reuse the pending row with the new value (same name, new ciphertext). An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/secrets (the `CreateSecret` operationId).
	CreateSecretWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateSecretResponse, error)

	// CreateSecretWithResponse Create a secret
	//
	// Creates an organization-scoped secret. Returns `409` if the name is already in use — including when a secret of that name is `pending_destroy`. List only shows active secrets, so a name can appear free while create still conflicts for as long as that row remains. A `pending_destroy` row is removed, and its name released, by a background sweep once no running worker can still hold the value — there is no deadline on that wait, so a continuously busy app can hold a name for as long as it runs. Recreate-while-deleting may later reuse the pending row with the new value (same name, new ciphertext). An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/secrets (the `CreateSecret` operationId).
	CreateSecretWithResponse(ctx context.Context, body CreateSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateSecretResponse, error)

	// DeleteSecretWithResponse Delete a secret
	//
	// Soft-deletes a secret: marks the row `pending_destroy` and bumps revision. This API does not hard-delete the row. Returns `409` while any app still attaches it — cascade-detach is not performed here; detach each holder with `DELETE .../apps/{id}/secrets/{name}` first, which rolls the deployments it names in place. A background sweep removes the row and releases the name once no running worker can still hold the value, rather than assuming every roll a detach started actually landed — a deployment that was not live when detached has nothing to roll until it resumes, so the sweep is the actual backstop, not the detach. While the row remains `pending_destroy` the name stays reserved, so create may return `409` even though list no longer shows the secret. Retries on an already-pending name are safe when no attachments remain (`204`); they still return `409` while attached.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/secrets/{secretName} (the `DeleteSecret` operationId).
	DeleteSecretWithResponse(ctx context.Context, secretName SecretName, reqEditors ...RequestEditorFn) (*DeleteSecretResponse, error)

	// UpdateSecretWithBodyWithResponse Update a secret
	//
	// Re-encrypts the value under the same name (no rename). Rolls every live deployment that attaches this secret in place so a running worker picks up the new value. If a rollout is already in progress when this commits, this change is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live picks it up on its next deploy for another reason. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/secrets/{secretName} (the `UpdateSecret` operationId).
	UpdateSecretWithBodyWithResponse(ctx context.Context, secretName SecretName, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateSecretResponse, error)

	// UpdateSecretWithResponse Update a secret
	//
	// Re-encrypts the value under the same name (no rename). Rolls every live deployment that attaches this secret in place so a running worker picks up the new value. If a rollout is already in progress when this commits, this change is not guaranteed to land on it — it reaches the worker on a later redeploy instead. A deployment that is not live picks it up on its next deploy for another reason. An organization whose serverless tenancy is revoked, or has no tenancy receipt at all, returns `403 Forbidden` — the per-organization CryptoKey that seals the value is only minted when the tenancy is active. An organization whose tenancy is still being provisioned returns `503 Service Unavailable` instead — that state is retryable, not a revocation, and clears once provisioning finishes.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PUT /v1/secrets/{secretName} (the `UpdateSecret` operationId).
	UpdateSecretWithResponse(ctx context.Context, secretName SecretName, body UpdateSecretJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateSecretResponse, error)

	// CreateSourceUploadWithBodyWithResponse Create a source upload
	//
	// Creates an upload session for a source archive. The session belongs to the authenticated organization and names no app: an upload precedes any app, and the source it publishes may back several. The response contains a short-lived transfer instruction for one exact staging object. Repeating the request with the same idempotency key and declaration while the session is pending and unexpired returns the same upload resource with a refreshed transfer instruction. Replays with a different declaration, or after the session becomes ready, rejected, expired, or deleted, return `409`.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/source-uploads (the `CreateSourceUpload` operationId).
	CreateSourceUploadWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateSourceUploadResponse, error)

	// CreateSourceUploadWithResponse Create a source upload
	//
	// Creates an upload session for a source archive. The session belongs to the authenticated organization and names no app: an upload precedes any app, and the source it publishes may back several. The response contains a short-lived transfer instruction for one exact staging object. Repeating the request with the same idempotency key and declaration while the session is pending and unexpired returns the same upload resource with a refreshed transfer instruction. Replays with a different declaration, or after the session becomes ready, rejected, expired, or deleted, return `409`.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/source-uploads (the `CreateSourceUpload` operationId).
	CreateSourceUploadWithResponse(ctx context.Context, body CreateSourceUploadJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateSourceUploadResponse, error)

	// DeleteSourceUploadWithResponse Abort a source upload
	//
	// Aborts an upload that has not published its source and removes its staging object. The session remains as a deleted tombstone so its staging key cannot be reused. Repeating a successful abort is idempotent. A `ready` upload cannot be aborted: the source it published is a resource in its own right, and the request answers `409` with type `source-upload-completed`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /v1/source-uploads/{uploadId} (the `DeleteSourceUpload` operationId).
	DeleteSourceUploadWithResponse(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*DeleteSourceUploadResponse, error)

	// GetSourceUploadWithResponse Get a source upload
	//
	// Returns the upload session belonging to the authenticated organization. Once the upload is `ready` the session carries the `sourceId` it published. An upload belonging to another organization returns `404`.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/source-uploads/{uploadId} (the `GetSourceUpload` operationId).
	GetSourceUploadWithResponse(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*GetSourceUploadResponse, error)

	// CompleteSourceUploadWithResponse Complete a source upload
	//
	// Verifies the staging object's length, content type, and SHA-256 digest against the session declaration, applies the archive rules for the source type, and publishes the verified bytes as an immutable source artifact. The first success creates the source and returns the ready session carrying its `sourceId`; a retry returns the same session and the same `sourceId`. A rejected upload keeps its rejection so later retries return the same result.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /v1/source-uploads/{uploadId}/complete (the `CompleteSourceUpload` operationId).
	CompleteSourceUploadWithResponse(ctx context.Context, uploadId SourceUploadId, reqEditors ...RequestEditorFn) (*CompleteSourceUploadResponse, error)

	// GetSourceWithResponse Get a source
	//
	// Returns the immutable source artifact a completed upload published: its type and the length and digest upload completion verified. A source is organization-scoped and may be named by any number of apps and versions in that organization; one belonging to another organization returns `404`. There is no list and no delete.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/sources/{sourceId} (the `GetSource` operationId).
	GetSourceWithResponse(ctx context.Context, sourceId SourceId, reqEditors ...RequestEditorFn) (*GetSourceResponse, error)

	// ListUsageEventsWithResponse List usage events
	//
	// Append-only billing telemetry; one row per worker state transition.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/usage (the `ListUsageEvents` operationId).
	ListUsageEventsWithResponse(ctx context.Context, params *ListUsageEventsParams, reqEditors ...RequestEditorFn) (*ListUsageEventsResponse, error)

	// GetUsageSummaryWithResponse Summarize usage over a time range
	//
	// GPU time and spend for the authenticated organization, aggregated over a half-open window and grouped by the dimensions asked for.
	//
	// Every figure is derived on read from the immutable usage ledger, the effective-dated price catalog and the organization's capacity commitments. Two consequences follow. The window is bounded, because the read folds every event of every worker in it. And a worker whose recorded life cannot be priced fails the request rather than being left out of the totals, because a total that silently omits usage is a wrong number a caller cannot see is wrong. These failures return `500`, with no partial totals.
	//
	// `paygSpend` is provisional pay-as-you-go accrual, not a settled charge. It excludes whole-second finalization rounding and ledger adjustments. `paygEquivalentValue` prices the same time at the catalog rate whatever covered it, so the difference between them is what a capacity commitment saved. While commitment coverage is not yet applied by settlement, an organization holding a commitment sees a split here that the credit ledger has not yet applied.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /v1/usage/summary (the `GetUsageSummary` operationId).
	GetUsageSummaryWithResponse(ctx context.Context, params *GetUsageSummaryParams, reqEditors ...RequestEditorFn) (*GetUsageSummaryResponse, error)
}