@aexhq/sdk 0.46.5-canary → 0.51.0

package/dist/generated/resources.d.ts

@@ -0,0 +1,710 @@
+/**
+ * The typed resource surface, one method per served operation.
+ *
+ * Nothing here is hand-maintained. A route that leaves the deferral ledger
+ * gains its method in the same regeneration that publishes it, and a route
+ * that enters the ledger loses it, so the published client surface is exactly
+ * what the platform answers.
+ */
+import type * as Models from "./models.js";
+import type { RouteId } from "./routes.js";
+/** The one client capability every generated resource method needs. */
+export interface ResourceExecutor {
+    execute<T>(routeId: RouteId, bindings?: Readonly<Record<string, string>>, options?: ExecuteOptions): Promise<T>;
+}
+/** Everything beyond the path a single call can carry. */
+export interface ExecuteOptions {
+    /** Query parameters, already rendered as wire strings. */
+    readonly query?: Readonly<Record<string, string>>;
+    /** The request body; binary routes require `Uint8Array`, all others use canonical JSON. */
+    readonly body?: unknown | Uint8Array;
+    /** `Idempotency-Key`, for a route that requires one. */
+    readonly idempotencyKey?: string;
+    /** `Aex-Operation-Id`, for a route that admits a durable operation. */
+    readonly operationId?: string;
+}
+/** The `api-keys` operations. */
+export declare class ApiKeysClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/api-keys` — Mint a workspace API key whose value is returned once. */
+    apiKeyCreate(params: {
+        readonly body: Models.ApiKeyCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.NewApiKey>;
+    /** `DELETE /api/api-keys/{apiKeyId}` — Revoke a workspace API key. */
+    apiKeyRevoke(params: {
+        readonly apiKeyId: Models.Id<"api_key">;
+    }): Promise<void>;
+    /** `GET /api/api-keys` — List workspace API key metadata. */
+    apiKeysList(params: {
+        readonly query: {
+            readonly cursor?: string;
+            readonly limit?: string;
+            readonly workspaceId: string;
+        };
+    }): Promise<Models.ApiKeyPage>;
+}
+/** The `auth` operations. */
+export declare class AuthClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/auth/sessions` — Exchange a provider authorization code for a browser session. */
+    dashboardSessionCreate(params: {
+        readonly body: Models.DashboardSessionRequest;
+    }): Promise<Models.DashboardSessionCredential>;
+    /** `DELETE /api/auth/sessions/current` — Close the browser session the caller presented. */
+    dashboardSessionDelete(): Promise<void>;
+    /** `POST /api/auth/device/authorizations` — Begin the CLI device-authorization flow. */
+    deviceAuthorizationCreate(params: {
+        readonly body: Models.DeviceAuthorizationRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.DeviceAuthorization>;
+    /** `POST /api/auth/device/decisions` — Approve or deny a pending device authorization. */
+    deviceDecisionCreate(params: {
+        readonly body: Models.DeviceDecisionRequest;
+    }): Promise<Models.DeviceDecisionResult>;
+    /** `POST /api/auth/device/tokens` — Exchange an approved device code for an account token. */
+    deviceTokenCreate(params: {
+        readonly body: Models.DeviceTokenRequest;
+    }): Promise<Models.DeviceToken>;
+}
+/** The `billing` operations. */
+export declare class BillingClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `GET /api/organizations/{organizationId}/billing/auto-topup-policy` — Read the automatic top-up policy. */
+    billingAutoTopupPolicyGet(params: {
+        readonly organizationId: Models.Id<"organization">;
+    }): Promise<Models.AutoTopupPolicy>;
+    /** `PUT /api/organizations/{organizationId}/billing/auto-topup-policy` — Replace the automatic top-up policy. */
+    billingAutoTopupPolicyPut(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly body: Models.AutoTopupPolicyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.AutoTopupPolicy>;
+    /** `GET /api/billing/balance` — Read the prepaid balance of an organization. */
+    billingBalanceGet(params?: {
+        readonly query?: {
+            readonly organizationId?: string;
+        };
+    }): Promise<Models.BillingBalance>;
+    /** `POST /api/organizations/{organizationId}/billing/portal-sessions` — Create a hosted billing portal session. */
+    billingPortalSessionCreate(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly body: Models.PortalSessionRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.HostedSession>;
+    /** `POST /api/organizations/{organizationId}/billing/statements/{statementId}/downloads` — Mint a download grant for an issued statement. */
+    billingStatementDownloadCreate(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly statementId: Models.Id<"statement">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.DownloadGrant>;
+    /** `GET /api/organizations/{organizationId}/billing/statements/{statementId}` — Read one immutable issued statement. */
+    billingStatementGet(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly statementId: Models.Id<"statement">;
+    }): Promise<Models.Statement>;
+    /** `GET /api/organizations/{organizationId}/billing/statements` — List issued statements, newest first. */
+    billingStatementsList(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+        };
+    }): Promise<Models.StatementSummaryPage>;
+    /** `POST /api/organizations/{organizationId}/billing/top-up-checkouts` — Create a hosted top-up checkout. */
+    billingTopUpCheckoutCreate(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly body: Models.TopUpCheckoutRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.HostedSession>;
+}
+/** The `bootstrap` operations. */
+export declare class BootstrapClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `GET /api/bootstrap` — One bounded read that fills the dashboard shell. */
+    dashboardBootstrapGet(): Promise<Models.DashboardBootstrap>;
+}
+/** The `files` operations. */
+export declare class FilesClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/sessions/{sessionId}/files/live/downloads/{fileDownloadId}/completion` — Re-stat, re-hash, and close an exact live-file download after SDK verification. */
+    sessionFilesLiveDownloadComplete(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileDownloadId: Models.Id<"file_download">;
+        readonly body: Models.LiveFileDownloadCompleteRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.LiveFileDownload>;
+    /** `POST /api/sessions/{sessionId}/files/live/downloads` — Open one exact-version live file directly from the retained generation, auto-resuming it. */
+    sessionFilesLiveDownloadCreate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.LiveFileDownloadRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.LiveFileDownload>;
+    /** `DELETE /api/sessions/{sessionId}/files/live/downloads/{fileDownloadId}` — Close an abandoned live-file descriptor, auto-resuming the same generation. */
+    sessionFilesLiveDownloadDelete(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileDownloadId: Models.Id<"file_download">;
+    }): Promise<void>;
+    /** `GET /api/sessions/{sessionId}/files/live/downloads/{fileDownloadId}/parts/{partNumber}` — Read one raw exact-version range directly from the retained generation. */
+    sessionFilesLiveDownloadPartGet(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileDownloadId: Models.Id<"file_download">;
+        readonly partNumber: number;
+        readonly query: {
+            readonly version: string;
+        };
+    }): Promise<Uint8Array>;
+    /** `POST /api/sessions/{sessionId}/files/live/list` — List the exact live generation, auto-resuming that same generation when suspended. */
+    sessionFilesLiveList(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.LiveFileListRequest;
+    }): Promise<Models.LiveFileEntryPage>;
+    /** `POST /api/sessions/{sessionId}/files/live/stat` — Stat one live path without following a symlink, auto-resuming the same generation. */
+    sessionFilesLiveStat(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.LiveFileStatRequest;
+    }): Promise<Models.LiveFileEntry>;
+    /** `POST /api/sessions/{sessionId}/files/live/uploads/{fileUploadId}/completion` — Verify every part and atomically publish one live file in the same generation. */
+    sessionFilesLiveUploadComplete(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileUploadId: Models.Id<"file_upload">;
+        readonly idempotencyKey: string;
+    }): Promise<Models.LiveFileUpload>;
+    /** `POST /api/sessions/{sessionId}/files/live/uploads` — Create a resumable upload in the exact live generation, auto-resuming it when suspended. */
+    sessionFilesLiveUploadCreate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.LiveFileUploadCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.LiveFileUpload>;
+    /** `DELETE /api/sessions/{sessionId}/files/live/uploads/{fileUploadId}` — Abort a partial upload, auto-resuming the same generation to remove its temporary bytes. */
+    sessionFilesLiveUploadDelete(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileUploadId: Models.Id<"file_upload">;
+    }): Promise<void>;
+    /** `GET /api/sessions/{sessionId}/files/live/uploads/{fileUploadId}` — Read resumable live-upload state, auto-resuming the same generation. */
+    sessionFilesLiveUploadGet(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileUploadId: Models.Id<"file_upload">;
+    }): Promise<Models.LiveFileUpload>;
+    /** `PUT /api/sessions/{sessionId}/files/live/uploads/{fileUploadId}/parts/{partNumber}` — Put one exact logical part directly into the retained generation. */
+    sessionFilesLiveUploadPartPut(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly fileUploadId: Models.Id<"file_upload">;
+        readonly partNumber: number;
+        readonly query: {
+            readonly sha256: string;
+        };
+        readonly body: Uint8Array;
+    }): Promise<Models.LiveFileUpload>;
+}
+/** The `identity` operations. */
+export declare class IdentityClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `GET /api/account` — Read the account and its operational state. */
+    accountGet(params: {
+        readonly query: {
+            readonly organizationId: string;
+        };
+    }): Promise<Models.AccountOperationalState>;
+}
+/** The `observations` operations. */
+export declare class ObservationsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/observations/events/query` — Query workspace events observations. */
+    observationsEventsQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/logs/query` — Query workspace logs observations. */
+    observationsLogsQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/metrics/aggregate` — Aggregate workspace metric observations. */
+    observationsMetricsAggregate(params: {
+        readonly body: Models.MetricAggregationRequest;
+    }): Promise<Models.MetricAggregationPage>;
+    /** `POST /api/observations/metrics/query` — Query workspace metrics observations. */
+    observationsMetricsQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/spans/query` — Query workspace spans observations. */
+    observationsSpansQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/telemetry/query` — Query workspace telemetry observations. */
+    observationsTelemetryQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/traces/query` — Query workspace traces observations. */
+    observationsTracesQuery(params: {
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/{sessionId}/events/query` — Query session events observations. */
+    sessionObservationsEventsQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/{sessionId}/logs/query` — Query session logs observations. */
+    sessionObservationsLogsQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/{sessionId}/metrics/aggregate` — Aggregate session metric observations. */
+    sessionObservationsMetricsAggregate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.MetricAggregationRequest;
+    }): Promise<Models.MetricAggregationPage>;
+    /** `POST /api/observations/{sessionId}/metrics/query` — Query session metrics observations. */
+    sessionObservationsMetricsQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/{sessionId}/spans/query` — Query session spans observations. */
+    sessionObservationsSpansQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `POST /api/observations/{sessionId}/telemetry/query` — Query session telemetry observations. */
+    sessionObservationsTelemetryQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+    /** `GET /api/observations/{sessionId}/traces/{traceId}` — Read one assembled trace by its W3C identifier. */
+    sessionObservationsTraceGet(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly traceId: string;
+    }): Promise<Models.TraceDetail>;
+    /** `POST /api/observations/{sessionId}/traces/query` — Query session traces observations. */
+    sessionObservationsTracesQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.ObservationQuery;
+    }): Promise<Models.ObservationPage>;
+}
+/** The `operations` operations. */
+export declare class OperationsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/operations/{operationId}/cancellations` — Request cancellation of a central operation. */
+    centralOperationCancel(params: {
+        readonly operationId: Models.Id<"operation">;
+        readonly body: Models.EmptyRequest;
+    }): Promise<Models.Operation>;
+    /** `GET /api/operations/{operationId}` — Read one central durable operation. */
+    centralOperationGet(params: {
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `GET /api/operations` — List central durable operations for one organization. */
+    centralOperationsList(params: {
+        readonly query: {
+            readonly cursor?: string;
+            readonly kind?: string;
+            readonly limit?: string;
+            readonly organizationId: string;
+            readonly status?: string;
+        };
+    }): Promise<Models.OperationPage>;
+    /** `POST /api/operations/{operationId}/cancellations` — Request cancellation of a regional operation. */
+    regionalOperationCancel(params: {
+        readonly operationId: Models.Id<"operation">;
+        readonly body: Models.EmptyRequest;
+    }): Promise<Models.Operation>;
+    /** `GET /api/operations/{operationId}` — Read one regional durable operation. */
+    regionalOperationGet(params: {
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `GET /api/operations` — List regional durable operations. */
+    regionalOperationsList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly kind?: string;
+            readonly limit?: string;
+            readonly sessionId?: string;
+            readonly status?: string;
+        };
+    }): Promise<Models.OperationPage>;
+}
+/** The `organizations` operations. */
+export declare class OrganizationsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/invitations/acceptances` — Redeem every pending invitation addressed to the caller's verified email. */
+    invitationAccept(params: {
+        readonly body: Models.EmptyRequest;
+    }): Promise<Models.InvitationAcceptResult>;
+    /** `POST /api/organizations/{organizationId}/invitations` — Invite a person to the organization. */
+    invitationCreate(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly body: Models.InvitationCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Invitation>;
+    /** `GET /api/organizations/{organizationId}/memberships` — List the memberships of an organization. */
+    membershipsList(params: {
+        readonly organizationId: Models.Id<"organization">;
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+        };
+    }): Promise<Models.MembershipPage>;
+    /** `POST /api/organizations` — Create an organization whose creator becomes owner. */
+    organizationCreate(params: {
+        readonly body: Models.OrganizationCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Organization>;
+    /** `GET /api/organizations/{organizationId}` — Read one organization. */
+    organizationGet(params: {
+        readonly organizationId: Models.Id<"organization">;
+    }): Promise<Models.Organization>;
+    /** `GET /api/organizations` — List organizations the caller belongs to. */
+    organizationsList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+        };
+    }): Promise<Models.OrganizationPage>;
+}
+/** The `otlp` operations. */
+export declare class OtlpClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/otlp/v1/logs` — Admit an OTLP logs batch. */
+    otlpLogsIngest(params: {
+        readonly body: unknown;
+        readonly idempotencyKey: string;
+    }): Promise<Models.TelemetryAdmissionReceipt>;
+    /** `POST /api/otlp/v1/metrics` — Admit an OTLP metrics batch. */
+    otlpMetricsIngest(params: {
+        readonly body: unknown;
+        readonly idempotencyKey: string;
+    }): Promise<Models.TelemetryAdmissionReceipt>;
+    /** `POST /api/otlp/v1/traces` — Admit an OTLP traces batch. */
+    otlpTracesIngest(params: {
+        readonly body: unknown;
+        readonly idempotencyKey: string;
+    }): Promise<Models.TelemetryAdmissionReceipt>;
+}
+/** The `provider-credentials` operations. */
+export declare class ProviderCredentialsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `GET /api/workspace/provider-credentials/{providerCredentialId}` — Read one BYOK provider-credential binding. */
+    providerCredentialGet(params: {
+        readonly providerCredentialId: Models.Id<"provider_credential">;
+    }): Promise<Models.ProviderCredential>;
+    /** `POST /api/workspace/provider-credentials` — Register a dedicated BYOK provider credential; carries plaintext once. */
+    providerCredentialRegister(params: {
+        readonly body: Models.ProviderCredentialRegisterRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.ProviderCredential>;
+    /** `POST /api/workspace/provider-credentials/{providerCredentialId}/revocations` — Revoke a BYOK provider-credential binding. */
+    providerCredentialRevoke(params: {
+        readonly providerCredentialId: Models.Id<"provider_credential">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.ProviderCredential>;
+    /** `GET /api/workspace/provider-credentials` — List BYOK provider-credential binding metadata. */
+    providerCredentialsList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+            readonly provider?: string;
+        };
+    }): Promise<Models.ProviderCredentialPage>;
+}
+/** The `registry` operations. */
+export declare class RegistryClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `DELETE /api/workspace/files/{name}` — Delete one registered workspace file. */
+    registryFilesDelete(params: {
+        readonly name: string;
+    }): Promise<void>;
+    /** `POST /api/workspace/files/{name}/downloads` — Mint a download grant for a registered workspace file. */
+    registryFilesDownloadCreate(params: {
+        readonly name: string;
+        readonly body: Models.RegistryDownloadRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.DownloadGrant>;
+    /** `GET /api/workspace/files/{name}` — Read one registered workspace file. */
+    registryFilesGet(params: {
+        readonly name: string;
+    }): Promise<Models.RegisteredFile>;
+    /** `GET /api/workspace/files` — List registered workspace files. */
+    registryFilesList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+        };
+    }): Promise<Models.RegisteredFilePage>;
+    /** `PUT /api/workspace/files/{name}` — Replace one registered workspace file. */
+    registryFilesPut(params: {
+        readonly name: string;
+        readonly body: Models.RegisteredFileValue;
+        readonly idempotencyKey: string;
+    }): Promise<Models.RegisteredFile>;
+}
+/** The `sessions` operations. */
+export declare class SessionsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/sessions/{sessionId}/cancellations` — Cancel current work and return the session to idle. */
+    sessionCancel(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.EmptyRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `POST /api/sessions` — Create an eight-hour multi-turn session. */
+    sessionCreate(params: {
+        readonly body: Models.SessionCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Session>;
+    /** `POST /api/sessions/{sessionId}/deletions` — Irreversibly delete the session and session-scoped user content, observations, telemetry, and export objects. Independent registered workspace files remain. */
+    sessionDelete(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.EmptyRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `GET /api/sessions/{sessionId}` — Read session metadata, including automatic lifecycle state, or its minimal deletion tombstone. */
+    sessionGet(params: {
+        readonly sessionId: Models.Id<"session">;
+    }): Promise<Models.Session>;
+    /** `POST /api/sessions/{sessionId}/messages` — Send text and start the session's next work, automatically resuming the same suspended generation. */
+    sessionMessageSend(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.MessageSendRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.MessageSendResult>;
+    /** `GET /api/sessions/{sessionId}/messages` — List complete sealed messages in immutable seal-visibility order. */
+    sessionMessagesList(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+        };
+    }): Promise<Models.MessagePage>;
+    /** `POST /api/sessions/{sessionId}/resumptions` — Resume the same retained generation to idle. */
+    sessionResume(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.EmptyRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `POST /api/sessions/{sessionId}/suspensions` — Suspend an idle session while retaining its exact generation; cancel active work first. */
+    sessionSuspend(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.EmptyRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `POST /api/sessions/{sessionId}/terminations` — Permanently destroy compute and live files while retaining metadata and sealed messages. */
+    sessionTerminate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.EmptyRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `GET /api/sessions` — List sessions in the workspace. */
+    sessionsList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+            readonly status?: string;
+        };
+    }): Promise<Models.SessionListPage>;
+}
+/** The `telemetry-lifecycle` operations. */
+export declare class TelemetryLifecycleClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/observations/{sessionId}/telemetry/exports` — Admit the durable session telemetry-export operation. */
+    sessionTelemetryExportCreate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.TelemetryExportRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `POST /api/observations/{sessionId}/telemetry/exports/{exportId}/downloads` — Mint a download grant for a ready session telemetry export. */
+    sessionTelemetryExportDownloadCreate(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly exportId: Models.Id<"export">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.DownloadGrant>;
+    /** `GET /api/observations/{sessionId}/telemetry/exports/{exportId}` — Read one session telemetry export record. */
+    sessionTelemetryExportGet(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly exportId: Models.Id<"export">;
+    }): Promise<Models.TelemetryExport>;
+    /** `POST /api/observations/{sessionId}/telemetry/exports/{exportId}/revocations` — Revoke a session telemetry export and its outstanding grants. */
+    sessionTelemetryExportRevoke(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly exportId: Models.Id<"export">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.TelemetryExport>;
+    /** `GET /api/observations/{sessionId}/telemetry/gaps/{gapId}` — Read one recorded session telemetry gap. */
+    sessionTelemetryGapGet(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly gapId: Models.Id<"telemetry_gap">;
+    }): Promise<Models.TelemetryGap>;
+    /** `POST /api/observations/{sessionId}/telemetry/gaps/query` — Query recorded session telemetry gaps. */
+    sessionTelemetryGapsQuery(params: {
+        readonly sessionId: Models.Id<"session">;
+        readonly body: Models.TelemetryGapQuery;
+    }): Promise<Models.TelemetryGapPage>;
+    /** `POST /api/observations/telemetry/exports` — Admit the durable workspace telemetry-export operation. */
+    telemetryExportCreate(params: {
+        readonly body: Models.TelemetryExportRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `POST /api/observations/telemetry/exports/{exportId}/downloads` — Mint a download grant for a ready telemetry export. */
+    telemetryExportDownloadCreate(params: {
+        readonly exportId: Models.Id<"export">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.DownloadGrant>;
+    /** `GET /api/observations/telemetry/exports/{exportId}` — Read one telemetry export record. */
+    telemetryExportGet(params: {
+        readonly exportId: Models.Id<"export">;
+    }): Promise<Models.TelemetryExport>;
+    /** `POST /api/observations/telemetry/exports/{exportId}/revocations` — Revoke a telemetry export and its outstanding grants. */
+    telemetryExportRevoke(params: {
+        readonly exportId: Models.Id<"export">;
+        readonly body: Models.EmptyRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.TelemetryExport>;
+    /** `GET /api/observations/telemetry/gaps/{gapId}` — Read one recorded telemetry gap. */
+    telemetryGapGet(params: {
+        readonly gapId: Models.Id<"telemetry_gap">;
+    }): Promise<Models.TelemetryGap>;
+    /** `POST /api/observations/telemetry/gaps/query` — Query recorded workspace telemetry gaps. */
+    telemetryGapsQuery(params: {
+        readonly body: Models.TelemetryGapQuery;
+    }): Promise<Models.TelemetryGapPage>;
+}
+/** The `uploads` operations. */
+export declare class UploadsClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `DELETE /api/workspace/uploads/{uploadId}` — Abort a staged upload. */
+    uploadAbort(params: {
+        readonly uploadId: Models.Id<"upload">;
+    }): Promise<void>;
+    /** `POST /api/workspace/uploads/{uploadId}/completion` — Complete a staged upload. */
+    uploadComplete(params: {
+        readonly uploadId: Models.Id<"upload">;
+        readonly body: Models.UploadCompleteRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Upload>;
+    /** `POST /api/workspace/uploads` — Stage a large registered-resource value. */
+    uploadCreate(params: {
+        readonly body: Models.UploadCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Upload>;
+    /** `POST /api/workspace/uploads/{uploadId}/parts` — Mint presigned PUT grants for the named parts. */
+    uploadPartsGrant(params: {
+        readonly uploadId: Models.Id<"upload">;
+        readonly body: Models.UploadPartsRequest;
+    }): Promise<Models.UploadPartGrants>;
+}
+/** The `usage` operations. */
+export declare class UsageClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/billing/usage/query` — Query rated usage for this workspace. */
+    usageQuery(params: {
+        readonly query?: {
+            readonly workspaceId?: string;
+        };
+        readonly body: Models.UsageQuery;
+    }): Promise<Models.UsagePage>;
+}
+/** The `workspace` operations. */
+export declare class WorkspaceClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `GET /api/workspace` — Read the workspace this credential is pinned to. */
+    workspaceCurrentGet(): Promise<Models.Workspace>;
+    /** `GET /api/workspace/limits/{limitId}` — Read one effective workspace safety limit. */
+    workspaceLimitGet(params: {
+        readonly limitId: "context.tool_result_bytes" | "session.materialized_agents" | "session.initial_files_bytes" | "session.initial_files_count" | "session.agent_execution" | "session.run_budget" | "api.json_body" | "telemetry.batch" | "telemetry.ingest_rate" | "telemetry.metric_series" | "query.filter" | "query.page" | "stream.frame" | "metric.aggregate" | "registry.entries" | "registry.value_bytes" | "telemetry.export";
+    }): Promise<Models.EffectiveWorkspaceLimit>;
+    /** `GET /api/workspace/limits` — List the effective workspace safety limits. The registry is closed and complete, so the whole set is one page and no continuation is ever minted. */
+    workspaceLimitsList(): Promise<Models.EffectiveWorkspaceLimitPage>;
+}
+/** The `workspaces` operations. */
+export declare class WorkspacesClient {
+    #private;
+    constructor(executor: ResourceExecutor);
+    /** `POST /api/workspaces` — Create a region-pinned workspace. */
+    workspaceCreate(params: {
+        readonly body: Models.WorkspaceCreateRequest;
+        readonly idempotencyKey: string;
+    }): Promise<Models.Workspace>;
+    /** `POST /api/workspaces/{workspaceId}/deletions` — Admit the global workspace-deletion operation. */
+    workspaceDelete(params: {
+        readonly workspaceId: Models.Id<"workspace">;
+        readonly body: Models.WorkspaceDeleteRequest;
+        readonly operationId: Models.Id<"operation">;
+    }): Promise<Models.Operation>;
+    /** `GET /api/workspaces/{workspaceId}` — Read one workspace. */
+    workspaceGet(params: {
+        readonly workspaceId: Models.Id<"workspace">;
+    }): Promise<Models.Workspace>;
+    /** `GET /api/workspaces` — List workspaces the caller can reach. */
+    workspacesList(params?: {
+        readonly query?: {
+            readonly cursor?: string;
+            readonly limit?: string;
+            readonly organizationId?: string;
+        };
+    }): Promise<Models.WorkspacePage>;
+}
+/**
+ * The resource namespaces the client exposes.
+ *
+ * The client extends this rather than listing the namespaces itself, so a
+ * fragment whose last served operation lands or leaves cannot be forgotten
+ * in the hand-written half.
+ */
+export declare abstract class GeneratedResources implements ResourceExecutor {
+    abstract execute<T>(routeId: RouteId, bindings?: Readonly<Record<string, string>>, options?: ExecuteOptions): Promise<T>;
+    /** The `api-keys` operations. */
+    readonly apiKeys: ApiKeysClient;
+    /** The `auth` operations. */
+    readonly auth: AuthClient;
+    /** The `billing` operations. */
+    readonly billing: BillingClient;
+    /** The `bootstrap` operations. */
+    readonly bootstrap: BootstrapClient;
+    /** The `files` operations. */
+    readonly files: FilesClient;
+    /** The `identity` operations. */
+    readonly identity: IdentityClient;
+    /** The `observations` operations. */
+    readonly observations: ObservationsClient;
+    /** The `operations` operations. */
+    readonly operations: OperationsClient;
+    /** The `organizations` operations. */
+    readonly organizations: OrganizationsClient;
+    /** The `otlp` operations. */
+    readonly otlp: OtlpClient;
+    /** The `provider-credentials` operations. */
+    readonly providerCredentials: ProviderCredentialsClient;
+    /** The `registry` operations. */
+    readonly registry: RegistryClient;
+    /** The `sessions` operations. */
+    readonly sessions: SessionsClient;
+    /** The `telemetry-lifecycle` operations. */
+    readonly telemetryLifecycle: TelemetryLifecycleClient;
+    /** The `uploads` operations. */
+    readonly uploads: UploadsClient;
+    /** The `usage` operations. */
+    readonly usage: UsageClient;
+    /** The `workspace` operations. */
+    readonly workspace: WorkspaceClient;
+    /** The `workspaces` operations. */
+    readonly workspaces: WorkspacesClient;
+}