@trycua/cua 0.2.0

package/browser/fleet_sdk.d.ts

@@ -0,0 +1,3056 @@
+import { type ClaimSpec, type OsGymSandboxClaimStatus, type OsGymSandboxTemplateSpec, type OsGymSandboxWarmPoolSpec, type OsGymSandboxWarmPoolStatus, type PreservedJsonLike } from "./cyclops_sdk_schema.js";
+import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, FfiConverterObjectWithCallbacks, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
+/**
+ * The `secret_files` key (and in-guest file name, `/run/cua/env-token`)
+ * that carries the cua-env-driver token for a claimed sandbox.
+ */
+export declare function claimEnvTokenKey(): string;
+/**
+ * The label key a fleet's claims share, for callers that filter or clean up
+ * with raw Kubernetes tooling instead of `list_fleet_claims`.
+ */
+export declare function fleetLabelKey(): string;
+export declare function healthyPoolDisplayStatus(): PoolDisplayStatus;
+export declare function poolDisplayStatus(pool: Pool): PoolDisplayStatus;
+/**
+ * The name prefix every tenant registry pull Secret must carry.
+ */
+export declare function registrySecretNamePrefix(): string;
+export declare function removedPoolDisplayStatus(): PoolDisplayStatus;
+export declare function terminatingPoolDisplayStatus(): PoolDisplayStatus;
+export declare function unknownPoolDisplayStatus(): PoolDisplayStatus;
+export type ResourceMetadata = {
+    namespace: string;
+    name: string;
+    labels?: Map<string, string>;
+    creationTimestamp?: string;
+};
+/**
+ * Generated factory for {@link ResourceMetadata} record objects.
+ */
+export declare const ResourceMetadata: Readonly<{
+    create: (partial: Partial<ResourceMetadata> & Required<Omit<ResourceMetadata, "name" | "namespace" | "labels" | "creationTimestamp">>) => ResourceMetadata;
+    new: (partial: Partial<ResourceMetadata> & Required<Omit<ResourceMetadata, "name" | "namespace" | "labels" | "creationTimestamp">>) => ResourceMetadata;
+    defaults: () => Partial<ResourceMetadata>;
+}>;
+export type Claim = {
+    apiVersion: string;
+    kind: string;
+    metadata: ResourceMetadata;
+    spec: ClaimSpec;
+    status?: OsGymSandboxClaimStatus;
+};
+/**
+ * Generated factory for {@link Claim} record objects.
+ */
+export declare const Claim: Readonly<{
+    create: (partial: Partial<Claim> & Required<Omit<Claim, "kind" | "status" | "apiVersion" | "metadata" | "spec">>) => Claim;
+    new: (partial: Partial<Claim> & Required<Omit<Claim, "kind" | "status" | "apiVersion" | "metadata" | "spec">>) => Claim;
+    defaults: () => Partial<Claim>;
+}>;
+/**
+ * UniFFI cannot emit aliases for external record types. Generated bindings use
+ * `OSGymSandboxWarmPoolStatus` and `OSGymSandboxClaimStatus` from cyclops_sdk_schema.
+ *
+ * A `Pool` is the `osgym.cua.ai/v1alpha1 OSGymSandboxWarmPool` CR verbatim —
+ * the SDK is a naive CRUD mapper over the native CRDs, with no translation
+ * layer (the legacy `cua.ai/v1 OSGymWorkspacePool` and its operator compat
+ * shim are gone).
+ */
+export type Pool = {
+    apiVersion: string;
+    kind: string;
+    metadata: ResourceMetadata;
+    spec: OsGymSandboxWarmPoolSpec;
+    status?: OsGymSandboxWarmPoolStatus;
+};
+/**
+ * Generated factory for {@link Pool} record objects.
+ */
+export declare const Pool: Readonly<{
+    create: (partial: Partial<Pool> & Required<Omit<Pool, "kind" | "status" | "apiVersion" | "metadata" | "spec">>) => Pool;
+    new: (partial: Partial<Pool> & Required<Omit<Pool, "kind" | "status" | "apiVersion" | "metadata" | "spec">>) => Pool;
+    defaults: () => Partial<Pool>;
+}>;
+export type CreateClaimRequest = {
+    pool: Pool;
+    spec?: ClaimSpec;
+    /**
+     * Explicit claim name. A client-supplied name is used verbatim (after
+     * DNS-label validation); left unset, the client generates a random
+     * `claim-<petname>` so concurrent leases and retries cannot collide.
+     */
+    name?: string;
+    /**
+     * Labels stamped onto the created claim's metadata verbatim. Grouping
+     * helpers (for example fleet fan-out) rely on this to tag related claims
+     * so they can be listed back by label within a namespace.
+     */
+    labels?: Map<string, string>;
+    /**
+     * Files delivered into the bound sandbox under `/run/cua/<key>` (mode
+     * 0600) once the claim binds, without restarting it. The key
+     * `claim_env_token_key()` (`env-token`) carries the cua-env-driver token.
+     * The client stores them in a claim-scoped `cua-claim-<claim>` Secret
+     * that the claim references by `spec.secretRef`; `delete_claim` removes
+     * it. The pool's template must set `vmTemplate.claimSecrets`. Values are
+     * never serialized with the request nor printed by `Debug`.
+     */
+    secretFiles?: Map<string, string>;
+};
+/**
+ * Generated factory for {@link CreateClaimRequest} record objects.
+ */
+export declare const CreateClaimRequest: Readonly<{
+    create: (partial: Partial<CreateClaimRequest> & Required<Omit<CreateClaimRequest, "name" | "labels" | "spec" | "pool" | "secretFiles">>) => CreateClaimRequest;
+    new: (partial: Partial<CreateClaimRequest> & Required<Omit<CreateClaimRequest, "name" | "labels" | "spec" | "pool" | "secretFiles">>) => CreateClaimRequest;
+    defaults: () => Partial<CreateClaimRequest>;
+}>;
+export type CreatePoolRequest = {
+    namespace: string;
+    spec: OsGymSandboxWarmPoolSpec;
+};
+/**
+ * Generated factory for {@link CreatePoolRequest} record objects.
+ */
+export declare const CreatePoolRequest: Readonly<{
+    create: (partial: Partial<CreatePoolRequest> & Required<Omit<CreatePoolRequest, "namespace" | "spec">>) => CreatePoolRequest;
+    new: (partial: Partial<CreatePoolRequest> & Required<Omit<CreatePoolRequest, "namespace" | "spec">>) => CreatePoolRequest;
+    defaults: () => Partial<CreatePoolRequest>;
+}>;
+/**
+ * Credentials for one registry, stored as a `cua-registry-*` pull Secret.
+ */
+export type CreateRegistrySecretRequest = {
+    /**
+     * Pool namespace the Secret is created in. It must already exist (the
+     * pool's namespace, created by `create_pool`, or by `create_namespace`).
+     */
+    namespace: string;
+    /**
+     * Full Secret name, `cua-registry-<dns-label>`.
+     */
+    name: string;
+    /**
+     * Registry host the credentials are for, as image refs spell it, e.g.
+     * `ghcr.io`, `registry.example.com:5000` or `docker.io`.
+     */
+    registry: string;
+    username: string;
+    /**
+     * Password or access token. Never serialized by `Debug`.
+     */
+    password: string;
+};
+/**
+ * Generated factory for {@link CreateRegistrySecretRequest} record objects.
+ */
+export declare const CreateRegistrySecretRequest: Readonly<{
+    create: (partial: Partial<CreateRegistrySecretRequest> & Required<Omit<CreateRegistrySecretRequest, "name" | "namespace" | "registry" | "username" | "password">>) => CreateRegistrySecretRequest;
+    new: (partial: Partial<CreateRegistrySecretRequest> & Required<Omit<CreateRegistrySecretRequest, "name" | "namespace" | "registry" | "username" | "password">>) => CreateRegistrySecretRequest;
+    defaults: () => Partial<CreateRegistrySecretRequest>;
+}>;
+export type Sandbox = {
+    namespace: string;
+    claim: string;
+    name: string;
+    services: Array<string>;
+};
+/**
+ * Generated factory for {@link Sandbox} record objects.
+ */
+export declare const Sandbox: Readonly<{
+    create: (partial: Partial<Sandbox> & Required<Omit<Sandbox, "name" | "namespace" | "claim" | "services">>) => Sandbox;
+    new: (partial: Partial<Sandbox> & Required<Omit<Sandbox, "name" | "namespace" | "claim" | "services">>) => Sandbox;
+    defaults: () => Partial<Sandbox>;
+}>;
+export type CreateSignedServiceUrlRequest = {
+    sandbox: Sandbox;
+    service: string;
+    label?: string;
+    expiresInSeconds: number;
+};
+/**
+ * Generated factory for {@link CreateSignedServiceUrlRequest} record objects.
+ */
+export declare const CreateSignedServiceUrlRequest: Readonly<{
+    create: (partial: Partial<CreateSignedServiceUrlRequest> & Required<Omit<CreateSignedServiceUrlRequest, "service" | "sandbox" | "label" | "expiresInSeconds">>) => CreateSignedServiceUrlRequest;
+    new: (partial: Partial<CreateSignedServiceUrlRequest> & Required<Omit<CreateSignedServiceUrlRequest, "service" | "sandbox" | "label" | "expiresInSeconds">>) => CreateSignedServiceUrlRequest;
+    defaults: () => Partial<CreateSignedServiceUrlRequest>;
+}>;
+export type CreateTemplateRequest = {
+    namespace: string;
+    name: string;
+    spec: OsGymSandboxTemplateSpec;
+};
+/**
+ * Generated factory for {@link CreateTemplateRequest} record objects.
+ */
+export declare const CreateTemplateRequest: Readonly<{
+    create: (partial: Partial<CreateTemplateRequest> & Required<Omit<CreateTemplateRequest, "name" | "namespace" | "spec">>) => CreateTemplateRequest;
+    new: (partial: Partial<CreateTemplateRequest> & Required<Omit<CreateTemplateRequest, "name" | "namespace" | "spec">>) => CreateTemplateRequest;
+    defaults: () => Partial<CreateTemplateRequest>;
+}>;
+export type CreateUserApiKeyRequest = {
+    name: string;
+    scope: Array<string>;
+};
+/**
+ * Generated factory for {@link CreateUserApiKeyRequest} record objects.
+ */
+export declare const CreateUserApiKeyRequest: Readonly<{
+    create: (partial: Partial<CreateUserApiKeyRequest> & Required<Omit<CreateUserApiKeyRequest, "name" | "scope">>) => CreateUserApiKeyRequest;
+    new: (partial: Partial<CreateUserApiKeyRequest> & Required<Omit<CreateUserApiKeyRequest, "name" | "scope">>) => CreateUserApiKeyRequest;
+    defaults: () => Partial<CreateUserApiKeyRequest>;
+}>;
+export interface CyclopsCredentialsLike {
+}
+/**
+ * @deprecated Use `CyclopsCredentialsLike` instead.
+ */
+export type CyclopsCredentialsInterface = CyclopsCredentialsLike;
+export declare class CyclopsCredentials extends UniffiAbstractObject implements CyclopsCredentialsLike {
+    readonly [uniffiTypeNameSymbol] = "CyclopsCredentials";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor(clientId: string, clientSecret: string);
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CyclopsCredentials;
+}
+export type CyclopsConfiguration = {
+    baseUrl: string;
+    tokenUrl: string;
+    credentials: CyclopsCredentialsLike;
+    poolPollIntervalMs: bigint;
+    poolPollLimit: number;
+    claimPollIntervalMs: bigint;
+    claimPollLimit: number;
+};
+/**
+ * Generated factory for {@link CyclopsConfiguration} record objects.
+ */
+export declare const CyclopsConfiguration: Readonly<{
+    create: (partial: Partial<CyclopsConfiguration> & Required<Omit<CyclopsConfiguration, "baseUrl" | "tokenUrl" | "credentials" | "poolPollIntervalMs" | "poolPollLimit" | "claimPollIntervalMs" | "claimPollLimit">>) => CyclopsConfiguration;
+    new: (partial: Partial<CyclopsConfiguration> & Required<Omit<CyclopsConfiguration, "baseUrl" | "tokenUrl" | "credentials" | "poolPollIntervalMs" | "poolPollLimit" | "claimPollIntervalMs" | "claimPollLimit">>) => CyclopsConfiguration;
+    defaults: () => Partial<CyclopsConfiguration>;
+}>;
+export type CyclopsTokenProviderConfiguration = {
+    baseUrl: string;
+    poolPollIntervalMs: bigint;
+    poolPollLimit: number;
+    claimPollIntervalMs: bigint;
+    claimPollLimit: number;
+};
+/**
+ * Generated factory for {@link CyclopsTokenProviderConfiguration} record objects.
+ */
+export declare const CyclopsTokenProviderConfiguration: Readonly<{
+    create: (partial: Partial<CyclopsTokenProviderConfiguration> & Required<Omit<CyclopsTokenProviderConfiguration, "baseUrl" | "poolPollIntervalMs" | "poolPollLimit" | "claimPollIntervalMs" | "claimPollLimit">>) => CyclopsTokenProviderConfiguration;
+    new: (partial: Partial<CyclopsTokenProviderConfiguration> & Required<Omit<CyclopsTokenProviderConfiguration, "baseUrl" | "poolPollIntervalMs" | "poolPollLimit" | "claimPollIntervalMs" | "claimPollLimit">>) => CyclopsTokenProviderConfiguration;
+    defaults: () => Partial<CyclopsTokenProviderConfiguration>;
+}>;
+/**
+ * A fleet's identity plus the claims currently known to belong to it.
+ */
+export type FleetClaims = {
+    fleetId: string;
+    claims: Array<Claim>;
+};
+/**
+ * Generated factory for {@link FleetClaims} record objects.
+ */
+export declare const FleetClaims: Readonly<{
+    create: (partial: Partial<FleetClaims> & Required<Omit<FleetClaims, "fleetId" | "claims">>) => FleetClaims;
+    new: (partial: Partial<FleetClaims> & Required<Omit<FleetClaims, "fleetId" | "claims">>) => FleetClaims;
+    defaults: () => Partial<FleetClaims>;
+}>;
+/**
+ * One pool's share of a fleet: claim `replicas` sandboxes from the warm pool
+ * named `pool`. On this platform the pool name is also its namespace.
+ */
+export type FleetPoolRequest = {
+    pool: string;
+    replicas: number;
+};
+/**
+ * Generated factory for {@link FleetPoolRequest} record objects.
+ */
+export declare const FleetPoolRequest: Readonly<{
+    create: (partial: Partial<FleetPoolRequest> & Required<Omit<FleetPoolRequest, "replicas" | "pool">>) => FleetPoolRequest;
+    new: (partial: Partial<FleetPoolRequest> & Required<Omit<FleetPoolRequest, "replicas" | "pool">>) => FleetPoolRequest;
+    defaults: () => Partial<FleetPoolRequest>;
+}>;
+export type HttpHeader = {
+    name: string;
+    value: string;
+};
+/**
+ * Generated factory for {@link HttpHeader} record objects.
+ */
+export declare const HttpHeader: Readonly<{
+    create: (partial: Partial<HttpHeader> & Required<Omit<HttpHeader, "name" | "value">>) => HttpHeader;
+    new: (partial: Partial<HttpHeader> & Required<Omit<HttpHeader, "name" | "value">>) => HttpHeader;
+    defaults: () => Partial<HttpHeader>;
+}>;
+export type HttpRequest = {
+    method: string;
+    url: string;
+    headers: Array<HttpHeader>;
+    body?: ArrayBuffer;
+    /**
+     * Per-request timeout. Defaults to absent so callers written against the
+     * pre-timeout record shape keep constructing requests unchanged; absent
+     * falls back to the native client's 30-second default.
+     */
+    timeoutSecs?: bigint;
+    /**
+     * Maximum bytes delivered in the response body. Absent preserves the
+     * historical unbounded response behavior.
+     */
+    maxResponseBytes?: bigint;
+};
+/**
+ * Generated factory for {@link HttpRequest} record objects.
+ */
+export declare const HttpRequest: Readonly<{
+    create: (partial: Partial<HttpRequest> & Required<Omit<HttpRequest, "body" | "method" | "url" | "headers" | "timeoutSecs" | "maxResponseBytes">>) => HttpRequest;
+    new: (partial: Partial<HttpRequest> & Required<Omit<HttpRequest, "body" | "method" | "url" | "headers" | "timeoutSecs" | "maxResponseBytes">>) => HttpRequest;
+    defaults: () => Partial<HttpRequest>;
+}>;
+export type HttpResponse = {
+    status: number;
+    headers: Array<HttpHeader>;
+    body: ArrayBuffer;
+};
+/**
+ * Generated factory for {@link HttpResponse} record objects.
+ */
+export declare const HttpResponse: Readonly<{
+    create: (partial: Partial<HttpResponse> & Required<Omit<HttpResponse, "status" | "body" | "headers">>) => HttpResponse;
+    new: (partial: Partial<HttpResponse> & Required<Omit<HttpResponse, "status" | "body" | "headers">>) => HttpResponse;
+    defaults: () => Partial<HttpResponse>;
+}>;
+export type ImageUploadFileRequest = {
+    digest: string;
+    sizeBytes: bigint;
+    name: string;
+};
+/**
+ * Generated factory for {@link ImageUploadFileRequest} record objects.
+ */
+export declare const ImageUploadFileRequest: Readonly<{
+    create: (partial: Partial<ImageUploadFileRequest> & Required<Omit<ImageUploadFileRequest, "name" | "digest" | "sizeBytes">>) => ImageUploadFileRequest;
+    new: (partial: Partial<ImageUploadFileRequest> & Required<Omit<ImageUploadFileRequest, "name" | "digest" | "sizeBytes">>) => ImageUploadFileRequest;
+    defaults: () => Partial<ImageUploadFileRequest>;
+}>;
+export type PresignedPut = {
+    method: string;
+    url: string;
+    headers: Map<string, string>;
+};
+/**
+ * Generated factory for {@link PresignedPut} record objects.
+ */
+export declare const PresignedPut: Readonly<{
+    create: (partial: Partial<PresignedPut> & Required<Omit<PresignedPut, "method" | "url" | "headers">>) => PresignedPut;
+    new: (partial: Partial<PresignedPut> & Required<Omit<PresignedPut, "method" | "url" | "headers">>) => PresignedPut;
+    defaults: () => Partial<PresignedPut>;
+}>;
+export type ImageUploadInstruction = {
+    digest: string;
+    sizeBytes: bigint;
+    reference: string;
+    upload?: PresignedPut;
+};
+/**
+ * Generated factory for {@link ImageUploadInstruction} record objects.
+ */
+export declare const ImageUploadInstruction: Readonly<{
+    create: (partial: Partial<ImageUploadInstruction> & Required<Omit<ImageUploadInstruction, "digest" | "sizeBytes" | "reference" | "upload">>) => ImageUploadInstruction;
+    new: (partial: Partial<ImageUploadInstruction> & Required<Omit<ImageUploadInstruction, "digest" | "sizeBytes" | "reference" | "upload">>) => ImageUploadInstruction;
+    defaults: () => Partial<ImageUploadInstruction>;
+}>;
+export type ImageUploadRequest = {
+    namespace: string;
+    files: Array<ImageUploadFileRequest>;
+};
+/**
+ * Generated factory for {@link ImageUploadRequest} record objects.
+ */
+export declare const ImageUploadRequest: Readonly<{
+    create: (partial: Partial<ImageUploadRequest> & Required<Omit<ImageUploadRequest, "namespace" | "files">>) => ImageUploadRequest;
+    new: (partial: Partial<ImageUploadRequest> & Required<Omit<ImageUploadRequest, "namespace" | "files">>) => ImageUploadRequest;
+    defaults: () => Partial<ImageUploadRequest>;
+}>;
+export type ImageUploadResponse = {
+    files: Array<ImageUploadInstruction>;
+};
+/**
+ * Generated factory for {@link ImageUploadResponse} record objects.
+ */
+export declare const ImageUploadResponse: Readonly<{
+    create: (partial: Partial<ImageUploadResponse> & Required<Omit<ImageUploadResponse, "files">>) => ImageUploadResponse;
+    new: (partial: Partial<ImageUploadResponse> & Required<Omit<ImageUploadResponse, "files">>) => ImageUploadResponse;
+    defaults: () => Partial<ImageUploadResponse>;
+}>;
+export type Namespace = {
+    name: string;
+    status: string;
+    createdAt: string;
+    labels?: Map<string, string>;
+};
+/**
+ * Generated factory for {@link Namespace} record objects.
+ */
+export declare const Namespace: Readonly<{
+    create: (partial: Partial<Namespace> & Required<Omit<Namespace, "name" | "status" | "labels" | "createdAt">>) => Namespace;
+    new: (partial: Partial<Namespace> & Required<Omit<Namespace, "name" | "status" | "labels" | "createdAt">>) => Namespace;
+    defaults: () => Partial<Namespace>;
+}>;
+export type NewUserApiKey = {
+    clientId: string;
+    clientSecret: string;
+    tokenUrl: string;
+    name: string;
+    scope: Array<string>;
+};
+/**
+ * Generated factory for {@link NewUserApiKey} record objects.
+ */
+export declare const NewUserApiKey: Readonly<{
+    create: (partial: Partial<NewUserApiKey> & Required<Omit<NewUserApiKey, "name" | "tokenUrl" | "scope" | "clientId" | "clientSecret">>) => NewUserApiKey;
+    new: (partial: Partial<NewUserApiKey> & Required<Omit<NewUserApiKey, "name" | "tokenUrl" | "scope" | "clientId" | "clientSecret">>) => NewUserApiKey;
+    defaults: () => Partial<NewUserApiKey>;
+}>;
+export declare enum PoolDisplayStatusKind {
+    Healthy = 0,
+    ScaledToZero = 1,
+    Removed = 2,
+    Terminating = 3,
+    Unknown = 4
+}
+export type PoolDisplayStatus = {
+    kind: PoolDisplayStatusKind;
+    label: string;
+    indicator: string;
+};
+/**
+ * Generated factory for {@link PoolDisplayStatus} record objects.
+ */
+export declare const PoolDisplayStatus: Readonly<{
+    create: (partial: Partial<PoolDisplayStatus> & Required<Omit<PoolDisplayStatus, "kind" | "label" | "indicator">>) => PoolDisplayStatus;
+    new: (partial: Partial<PoolDisplayStatus> & Required<Omit<PoolDisplayStatus, "kind" | "label" | "indicator">>) => PoolDisplayStatus;
+    defaults: () => Partial<PoolDisplayStatus>;
+}>;
+/**
+ * A created registry pull Secret. Carries no credential: Secrets are
+ * write-only through the gateway.
+ */
+export type RegistrySecret = {
+    namespace: string;
+    name: string;
+    registry: string;
+};
+/**
+ * Generated factory for {@link RegistrySecret} record objects.
+ */
+export declare const RegistrySecret: Readonly<{
+    create: (partial: Partial<RegistrySecret> & Required<Omit<RegistrySecret, "name" | "namespace" | "registry">>) => RegistrySecret;
+    new: (partial: Partial<RegistrySecret> & Required<Omit<RegistrySecret, "name" | "namespace" | "registry">>) => RegistrySecret;
+    defaults: () => Partial<RegistrySecret>;
+}>;
+/**
+ * A registry ref pinned by the gateway (`GET /api/images/resolve`).
+ */
+export type ResolvedImage = {
+    /**
+     * The ref as requested.
+     */
+    reference: string;
+    /**
+     * The ref actually resolved: for a canonical image and runtime
+     * `kubevirt` this is the containerDisk sibling (`…:24.04-disk`).
+     */
+    resolvedRef: string;
+    /**
+     * `repo@sha256:…` of the manifest (or index) to run.
+     */
+    pinnedRef: string;
+    digest: string;
+    /**
+     * `rootfs` (docker/gVisor), `containerdisk` (KubeVirt) or `unknown`.
+     */
+    variant: string;
+    /**
+     * The linux/amd64 child manifest digest when the ref is an index.
+     */
+    platformDigest?: string;
+    mediaType: string;
+};
+/**
+ * Generated factory for {@link ResolvedImage} record objects.
+ */
+export declare const ResolvedImage: Readonly<{
+    create: (partial: Partial<ResolvedImage> & Required<Omit<ResolvedImage, "digest" | "reference" | "resolvedRef" | "pinnedRef" | "variant" | "platformDigest" | "mediaType">>) => ResolvedImage;
+    new: (partial: Partial<ResolvedImage> & Required<Omit<ResolvedImage, "digest" | "reference" | "resolvedRef" | "pinnedRef" | "variant" | "platformDigest" | "mediaType">>) => ResolvedImage;
+    defaults: () => Partial<ResolvedImage>;
+}>;
+/**
+ * Where a native client opens its own WebSocket to a sandbox service through
+ * the gateway's `/api/svc` proxy. `url` is the `ws(s)://` endpoint;
+ * `auth_header_name`/`auth_header_value` carry the bearer the socket's HTTP
+ * upgrade request must send. Deliberately not serde-serializable: the value
+ * holds a live credential and must not be logged or persisted.
+ */
+export type ServiceStreamTarget = {
+    url: string;
+    authHeaderName: string;
+    authHeaderValue: string;
+};
+/**
+ * Generated factory for {@link ServiceStreamTarget} record objects.
+ */
+export declare const ServiceStreamTarget: Readonly<{
+    create: (partial: Partial<ServiceStreamTarget> & Required<Omit<ServiceStreamTarget, "url" | "authHeaderName" | "authHeaderValue">>) => ServiceStreamTarget;
+    new: (partial: Partial<ServiceStreamTarget> & Required<Omit<ServiceStreamTarget, "url" | "authHeaderName" | "authHeaderValue">>) => ServiceStreamTarget;
+    defaults: () => Partial<ServiceStreamTarget>;
+}>;
+export type SignedServiceUrl = {
+    id: string;
+    namespace: string;
+    claim: string;
+    sandbox: string;
+    service: string;
+    label?: string;
+    url: string;
+    createdAt: string;
+    expiresAt: string;
+    revokedAt?: string;
+};
+/**
+ * Generated factory for {@link SignedServiceUrl} record objects.
+ */
+export declare const SignedServiceUrl: Readonly<{
+    create: (partial: Partial<SignedServiceUrl> & Required<Omit<SignedServiceUrl, "namespace" | "claim" | "service" | "sandbox" | "label" | "url" | "createdAt" | "id" | "expiresAt" | "revokedAt">>) => SignedServiceUrl;
+    new: (partial: Partial<SignedServiceUrl> & Required<Omit<SignedServiceUrl, "namespace" | "claim" | "service" | "sandbox" | "label" | "url" | "createdAt" | "id" | "expiresAt" | "revokedAt">>) => SignedServiceUrl;
+    defaults: () => Partial<SignedServiceUrl>;
+}>;
+/**
+ * The `osgym.cua.ai/v1alpha1 OSGymSandboxTemplate` CR verbatim. Warm pools
+ * and claims reference one by name via `spec.sandboxTemplateRef.name`.
+ */
+export type Template = {
+    apiVersion: string;
+    kind: string;
+    metadata: ResourceMetadata;
+    spec: OsGymSandboxTemplateSpec;
+};
+/**
+ * Generated factory for {@link Template} record objects.
+ */
+export declare const Template: Readonly<{
+    create: (partial: Partial<Template> & Required<Omit<Template, "kind" | "apiVersion" | "metadata" | "spec">>) => Template;
+    new: (partial: Partial<Template> & Required<Omit<Template, "kind" | "apiVersion" | "metadata" | "spec">>) => Template;
+    defaults: () => Partial<Template>;
+}>;
+export type UserApiKey = {
+    id: string;
+    clientId: string;
+    name: string;
+    scope: Array<string>;
+};
+/**
+ * Generated factory for {@link UserApiKey} record objects.
+ */
+export declare const UserApiKey: Readonly<{
+    create: (partial: Partial<UserApiKey> & Required<Omit<UserApiKey, "name" | "scope" | "clientId" | "id">>) => UserApiKey;
+    new: (partial: Partial<UserApiKey> & Required<Omit<UserApiKey, "name" | "scope" | "clientId" | "id">>) => UserApiKey;
+    defaults: () => Partial<UserApiKey>;
+}>;
+export declare enum AccessTokenProviderError_Tags {
+    Failed = "Failed"
+}
+export declare const AccessTokenProviderError: Readonly<{
+    instanceOf: (obj: any) => obj is AccessTokenProviderError;
+    Failed: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: AccessTokenProviderError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: AccessTokenProviderError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: AccessTokenProviderError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: AccessTokenProviderError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: AccessTokenProviderError_Tags.Failed;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type AccessTokenProviderError = InstanceType<typeof AccessTokenProviderError['Failed']>;
+export declare enum HttpError_Tags {
+    Transport = "Transport"
+}
+export declare const HttpError: Readonly<{
+    instanceOf: (obj: any) => obj is HttpError;
+    Transport: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: HttpError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "HttpError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: HttpError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "HttpError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: HttpError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "HttpError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: HttpError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "HttpError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: HttpError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "HttpError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type HttpError = InstanceType<typeof HttpError['Transport']>;
+export declare enum SdkBuildError_Tags {
+    MissingRequiredField = "MissingRequiredField"
+}
+export declare const SdkBuildError: Readonly<{
+    instanceOf: (obj: any) => obj is SdkBuildError;
+    MissingRequiredField: {
+        new (inner: {
+            recordType: string;
+            field: string;
+        }): {
+            readonly tag: SdkBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            recordType: string;
+            field: string;
+        }): {
+            readonly tag: SdkBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            recordType: string;
+            field: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type SdkBuildError = InstanceType<typeof SdkBuildError['MissingRequiredField']>;
+export declare enum SdkError_Tags {
+    Configuration = "Configuration",
+    InvalidResourceName = "InvalidResourceName",
+    Transport = "Transport",
+    Token = "Token",
+    Body = "Body",
+    Status = "Status",
+    SignedServiceUrlsUnavailable = "SignedServiceUrlsUnavailable",
+    UnknownService = "UnknownService",
+    InvalidServicePath = "InvalidServicePath",
+    ClaimFailed = "ClaimFailed",
+    ClaimTimeout = "ClaimTimeout",
+    PoolAccessDenied = "PoolAccessDenied"
+}
+export declare const SdkError: Readonly<{
+    instanceOf: (obj: any) => obj is SdkError;
+    Configuration: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.Configuration;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidResourceName: {
+        new (inner: {
+            field: string;
+            value: string;
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.InvalidResourceName;
+            readonly inner: Readonly<{
+                field: string;
+                value: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            field: string;
+            value: string;
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.InvalidResourceName;
+            readonly inner: Readonly<{
+                field: string;
+                value: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidResourceName;
+            readonly inner: Readonly<{
+                field: string;
+                value: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidResourceName;
+            readonly inner: Readonly<{
+                field: string;
+                value: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InvalidResourceName;
+            readonly inner: Readonly<{
+                field: string;
+                value: string;
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            field: string;
+            value: string;
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Transport: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.Transport;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Token: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Token;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Token;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.Token;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.Token;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.Token;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Body: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Body;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: SdkError_Tags.Body;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.Body;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.Body;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.Body;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            reason: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Status: {
+        new (inner: {
+            operation: string;
+            status: number;
+            body: string;
+        }): {
+            readonly tag: SdkError_Tags.Status;
+            readonly inner: Readonly<{
+                operation: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            operation: string;
+            status: number;
+            body: string;
+        }): {
+            readonly tag: SdkError_Tags.Status;
+            readonly inner: Readonly<{
+                operation: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.Status;
+            readonly inner: Readonly<{
+                operation: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.Status;
+            readonly inner: Readonly<{
+                operation: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.Status;
+            readonly inner: Readonly<{
+                operation: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            operation: string;
+            status: number;
+            body: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    SignedServiceUrlsUnavailable: {
+        new (): {
+            readonly tag: SdkError_Tags.SignedServiceUrlsUnavailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: SdkError_Tags.SignedServiceUrlsUnavailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.SignedServiceUrlsUnavailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.SignedServiceUrlsUnavailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    UnknownService: {
+        new (inner: {
+            requested: string;
+            available: Array<string>;
+        }): {
+            readonly tag: SdkError_Tags.UnknownService;
+            readonly inner: Readonly<{
+                requested: string;
+                available: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            requested: string;
+            available: Array<string>;
+        }): {
+            readonly tag: SdkError_Tags.UnknownService;
+            readonly inner: Readonly<{
+                requested: string;
+                available: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.UnknownService;
+            readonly inner: Readonly<{
+                requested: string;
+                available: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.UnknownService;
+            readonly inner: Readonly<{
+                requested: string;
+                available: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.UnknownService;
+            readonly inner: Readonly<{
+                requested: string;
+                available: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            requested: string;
+            available: Array<string>;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidServicePath: {
+        new (inner: {
+            path: string;
+        }): {
+            readonly tag: SdkError_Tags.InvalidServicePath;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            path: string;
+        }): {
+            readonly tag: SdkError_Tags.InvalidServicePath;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidServicePath;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidServicePath;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InvalidServicePath;
+            readonly inner: Readonly<{
+                path: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            path: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    ClaimFailed: {
+        new (inner: {
+            phase: string;
+            status: string;
+        }): {
+            readonly tag: SdkError_Tags.ClaimFailed;
+            readonly inner: Readonly<{
+                phase: string;
+                status: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            phase: string;
+            status: string;
+        }): {
+            readonly tag: SdkError_Tags.ClaimFailed;
+            readonly inner: Readonly<{
+                phase: string;
+                status: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.ClaimFailed;
+            readonly inner: Readonly<{
+                phase: string;
+                status: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.ClaimFailed;
+            readonly inner: Readonly<{
+                phase: string;
+                status: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.ClaimFailed;
+            readonly inner: Readonly<{
+                phase: string;
+                status: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            phase: string;
+            status: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    ClaimTimeout: {
+        new (): {
+            readonly tag: SdkError_Tags.ClaimTimeout;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(): {
+            readonly tag: SdkError_Tags.ClaimTimeout;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.ClaimTimeout;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.ClaimTimeout;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    PoolAccessDenied: {
+        new (inner: {
+            operation: string;
+            namespace: string;
+            status: number;
+            body: string;
+        }): {
+            readonly tag: SdkError_Tags.PoolAccessDenied;
+            readonly inner: Readonly<{
+                operation: string;
+                namespace: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            operation: string;
+            namespace: string;
+            status: number;
+            body: string;
+        }): {
+            readonly tag: SdkError_Tags.PoolAccessDenied;
+            readonly inner: Readonly<{
+                operation: string;
+                namespace: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.PoolAccessDenied;
+            readonly inner: Readonly<{
+                operation: string;
+                namespace: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.PoolAccessDenied;
+            readonly inner: Readonly<{
+                operation: string;
+                namespace: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.PoolAccessDenied;
+            readonly inner: Readonly<{
+                operation: string;
+                namespace: string;
+                status: number;
+                body: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            operation: string;
+            namespace: string;
+            status: number;
+            body: string;
+        }>;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+export type SdkError = InstanceType<typeof SdkError['Configuration' | 'InvalidResourceName' | 'Transport' | 'Token' | 'Body' | 'Status' | 'SignedServiceUrlsUnavailable' | 'UnknownService' | 'InvalidServicePath' | 'ClaimFailed' | 'ClaimTimeout' | 'PoolAccessDenied']>;
+export interface AccessTokenProvider {
+    getAccessToken(forceRefresh: boolean, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<string>;
+}
+export declare class AccessTokenProviderImpl extends UniffiAbstractObject implements AccessTokenProvider {
+    readonly [uniffiTypeNameSymbol] = "AccessTokenProviderImpl";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    getAccessToken(forceRefresh: boolean, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<string>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is AccessTokenProviderImpl;
+}
+export interface CreateClaimRequestBuilderLike {
+    build(): CreateClaimRequest;
+    labels(value: Map<string, string>): CreateClaimRequestBuilderLike;
+    name(value: string): CreateClaimRequestBuilderLike;
+    pool(value: Pool): CreateClaimRequestBuilderLike;
+    secretFiles(value: Map<string, string>): CreateClaimRequestBuilderLike;
+    spec(value: ClaimSpec): CreateClaimRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreateClaimRequestBuilderLike` instead.
+ */
+export type CreateClaimRequestBuilderInterface = CreateClaimRequestBuilderLike;
+export declare class CreateClaimRequestBuilder extends UniffiAbstractObject implements CreateClaimRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreateClaimRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreateClaimRequest;
+    labels(value: Map<string, string>): CreateClaimRequestBuilderLike;
+    name(value: string): CreateClaimRequestBuilderLike;
+    pool(value: Pool): CreateClaimRequestBuilderLike;
+    secretFiles(value: Map<string, string>): CreateClaimRequestBuilderLike;
+    spec(value: ClaimSpec): CreateClaimRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreateClaimRequestBuilder;
+}
+export interface CreatePoolRequestBuilderLike {
+    build(): CreatePoolRequest;
+    namespace(value: string): CreatePoolRequestBuilderLike;
+    spec(value: OsGymSandboxWarmPoolSpec): CreatePoolRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreatePoolRequestBuilderLike` instead.
+ */
+export type CreatePoolRequestBuilderInterface = CreatePoolRequestBuilderLike;
+export declare class CreatePoolRequestBuilder extends UniffiAbstractObject implements CreatePoolRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreatePoolRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreatePoolRequest;
+    namespace(value: string): CreatePoolRequestBuilderLike;
+    spec(value: OsGymSandboxWarmPoolSpec): CreatePoolRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreatePoolRequestBuilder;
+}
+export interface CreateRegistrySecretRequestBuilderLike {
+    build(): CreateRegistrySecretRequest;
+    name(value: string): CreateRegistrySecretRequestBuilderLike;
+    namespace(value: string): CreateRegistrySecretRequestBuilderLike;
+    password(value: string): CreateRegistrySecretRequestBuilderLike;
+    registry(value: string): CreateRegistrySecretRequestBuilderLike;
+    username(value: string): CreateRegistrySecretRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreateRegistrySecretRequestBuilderLike` instead.
+ */
+export type CreateRegistrySecretRequestBuilderInterface = CreateRegistrySecretRequestBuilderLike;
+export declare class CreateRegistrySecretRequestBuilder extends UniffiAbstractObject implements CreateRegistrySecretRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreateRegistrySecretRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreateRegistrySecretRequest;
+    name(value: string): CreateRegistrySecretRequestBuilderLike;
+    namespace(value: string): CreateRegistrySecretRequestBuilderLike;
+    password(value: string): CreateRegistrySecretRequestBuilderLike;
+    registry(value: string): CreateRegistrySecretRequestBuilderLike;
+    username(value: string): CreateRegistrySecretRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreateRegistrySecretRequestBuilder;
+}
+export interface CreateSignedServiceUrlRequestBuilderLike {
+    build(): CreateSignedServiceUrlRequest;
+    expiresInSeconds(value: number): CreateSignedServiceUrlRequestBuilderLike;
+    label(value: string): CreateSignedServiceUrlRequestBuilderLike;
+    sandbox(value: Sandbox): CreateSignedServiceUrlRequestBuilderLike;
+    service(value: string): CreateSignedServiceUrlRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreateSignedServiceUrlRequestBuilderLike` instead.
+ */
+export type CreateSignedServiceUrlRequestBuilderInterface = CreateSignedServiceUrlRequestBuilderLike;
+export declare class CreateSignedServiceUrlRequestBuilder extends UniffiAbstractObject implements CreateSignedServiceUrlRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreateSignedServiceUrlRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreateSignedServiceUrlRequest;
+    expiresInSeconds(value: number): CreateSignedServiceUrlRequestBuilderLike;
+    label(value: string): CreateSignedServiceUrlRequestBuilderLike;
+    sandbox(value: Sandbox): CreateSignedServiceUrlRequestBuilderLike;
+    service(value: string): CreateSignedServiceUrlRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreateSignedServiceUrlRequestBuilder;
+}
+export interface CreateTemplateRequestBuilderLike {
+    build(): CreateTemplateRequest;
+    name(value: string): CreateTemplateRequestBuilderLike;
+    namespace(value: string): CreateTemplateRequestBuilderLike;
+    spec(value: OsGymSandboxTemplateSpec): CreateTemplateRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreateTemplateRequestBuilderLike` instead.
+ */
+export type CreateTemplateRequestBuilderInterface = CreateTemplateRequestBuilderLike;
+export declare class CreateTemplateRequestBuilder extends UniffiAbstractObject implements CreateTemplateRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreateTemplateRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreateTemplateRequest;
+    name(value: string): CreateTemplateRequestBuilderLike;
+    namespace(value: string): CreateTemplateRequestBuilderLike;
+    spec(value: OsGymSandboxTemplateSpec): CreateTemplateRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreateTemplateRequestBuilder;
+}
+export interface CreateUserApiKeyRequestBuilderLike {
+    build(): CreateUserApiKeyRequest;
+    name(value: string): CreateUserApiKeyRequestBuilderLike;
+    scope(value: Array<string>): CreateUserApiKeyRequestBuilderLike;
+}
+/**
+ * @deprecated Use `CreateUserApiKeyRequestBuilderLike` instead.
+ */
+export type CreateUserApiKeyRequestBuilderInterface = CreateUserApiKeyRequestBuilderLike;
+export declare class CreateUserApiKeyRequestBuilder extends UniffiAbstractObject implements CreateUserApiKeyRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CreateUserApiKeyRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): CreateUserApiKeyRequest;
+    name(value: string): CreateUserApiKeyRequestBuilderLike;
+    scope(value: Array<string>): CreateUserApiKeyRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CreateUserApiKeyRequestBuilder;
+}
+export interface CyclopsClientLike {
+    /**
+     * The bearer this client would send on its next authenticated request,
+     * for callers that open their own connection to the gateway (for example
+     * a native WebSocket). `force_refresh` bypasses any cached token; a
+     * static access token is returned as-is. The value is a raw token — the
+     * caller attaches it as `authorization: Bearer <token>`.
+     */
+    accessToken(forceRefresh: boolean, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<string>;
+    createClaim(request: CreateClaimRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    /**
+     * Fan out `create_claim` calls across the requested warm pools, tagging
+     * every claim with `cua.ai/fleet=<fleet_id>` so the group can be listed
+     * back later. Duplicate pool entries are aggregated before any network
+     * call. Claims are created sequentially; if one creation fails the error
+     * is returned immediately and claims already created keep their fleet
+     * label, so `list_fleet_claims` still finds them for retry or cleanup.
+     */
+    createFleetClaims(fleetId: string, requests: Array<FleetPoolRequest>, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<FleetClaims>;
+    createImage(namespace: string, manifest: PreservedJsonLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PreservedJsonLike>;
+    createNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Namespace>;
+    createPool(request: CreatePoolRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    /**
+     * Create (or replace) a `cua-registry-*` dockerconfigjson pull Secret.
+     * On a name conflict the old Secret is deleted and the new one created,
+     * since the gateway admits no Secret update.
+     */
+    createRegistrySecret(request: CreateRegistrySecretRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<RegistrySecret>;
+    createSignedServiceUrl(request: CreateSignedServiceUrlRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SignedServiceUrl>;
+    createTemplate(request: CreateTemplateRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    createUserApiKey(request: CreateUserApiKeyRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<NewUserApiKey>;
+    /**
+     * Delete the claim and, when it references a claim-scoped Secret
+     * (`secret_files`), that Secret too. The pool-operator also owner-refs
+     * the Secret to the claim, so garbage collection is the backstop.
+     */
+    deleteClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteImage(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deletePool(pool: Pool, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteRegistrySecret(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteTemplate(template: Template, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteUserApiKey(id: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    getClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    getImage(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PreservedJsonLike>;
+    getNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Namespace>;
+    getPool(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    getTemplate(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    listClaims(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Claim>>;
+    /**
+     * The fleet's claims within one namespace: enumerate the namespace's
+     * claims and keep those labeled `cua.ai/fleet=<fleet_id>`. A fleet that
+     * spans several pools spans that many namespaces (one pool per
+     * namespace), so call this once per member pool.
+     */
+    listFleetClaims(namespace: string, fleetId: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<FleetClaims>;
+    listImages(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<PreservedJsonLike>>;
+    listNamespaces(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Namespace>>;
+    listPools(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Pool>>;
+    listSignedServiceUrls(sandbox: Sandbox, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SignedServiceUrl>>;
+    listTemplates(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Template>>;
+    listUserApiKeys(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<UserApiKey>>;
+    presignImageUploads(request: ImageUploadRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ImageUploadResponse>;
+    reconcilePool(request: CreatePoolRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    reconcileTemplate(request: CreateTemplateRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    /**
+     * Push the claim's `spec.lifecycle.shutdownTime` forward. That absolute
+     * expiry is the only liveness input the pool operator's claim reaper
+     * honors, so a holder that outlives its current lease must renew before
+     * the deadline passes or the bound sandbox is deleted underneath it.
+     * Deliberately narrower than a claim update: nothing else on the claim
+     * can be mutated through the SDK.
+     */
+    renewClaim(claim: Claim, shutdownTime: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    /**
+     * Pin a public registry ref to a digest server-side. `runtime` (`gvisor`,
+     * `kubevirt`, `macos`) selects the variant for canonical cua images:
+     * `kubevirt` maps `ghcr.io/trycua/linux:24.04` to its `-disk` sibling.
+     */
+    resolveImage(reference: string, runtime: string | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ResolvedImage>;
+    revokeSignedServiceUrl(signedServiceUrl: SignedServiceUrl, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    serviceRequest(sandbox: Sandbox, service: string, path: string, request: HttpRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<HttpResponse>;
+    /**
+     * Where a native client opens its own WebSocket to a sandbox service:
+     * the gateway's `/api/svc` proxy forwards the HTTP upgrade, so the
+     * returned `ws(s)://` URL plus the returned bearer header are all a
+     * Rust or Swift caller needs to dial the socket directly.
+     * `service_request` stays the path for unary requests.
+     */
+    serviceWebsocketUrl(sandbox: Sandbox, service: string, path: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ServiceStreamTarget>;
+    updatePool(pool: Pool, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    updateTemplate(template: Template, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    /**
+     * Hash and upload one file, or reuse a matching existing object.
+     * Returns only the bound digest, size, and tenant reference, never a signed URL.
+     * This does not create an Image or attest to object versioning/encryption.
+     */
+    uploadImageFile(namespace: string, name: string, contents: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ImageUploadInstruction>;
+    waitClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Sandbox>;
+}
+/**
+ * @deprecated Use `CyclopsClientLike` instead.
+ */
+export type CyclopsClientInterface = CyclopsClientLike;
+export declare class CyclopsClient extends UniffiAbstractObject implements CyclopsClientLike {
+    readonly [uniffiTypeNameSymbol] = "CyclopsClient";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    static connect(configuration: CyclopsConfiguration, httpClient: HttpClient): CyclopsClientLike;
+    static connectBrowserWithAccessToken(configuration: CyclopsTokenProviderConfiguration, accessToken: string): CyclopsClientLike;
+    static connectWithAccessToken(configuration: CyclopsTokenProviderConfiguration, accessToken: string, httpClient: HttpClient): CyclopsClientLike;
+    static connectWithAccessTokenAndNativeHttpClient(configuration: CyclopsTokenProviderConfiguration, accessToken: string): CyclopsClientLike;
+    static connectWithAccessTokenProvider(configuration: CyclopsTokenProviderConfiguration, tokenProvider: AccessTokenProvider, httpClient: HttpClient): CyclopsClientLike;
+    static connectWithAccessTokenProviderAndNativeHttpClient(configuration: CyclopsTokenProviderConfiguration, tokenProvider: AccessTokenProvider): CyclopsClientLike;
+    static connectWithNativeHttpClient(configuration: CyclopsConfiguration): CyclopsClientLike;
+    /**
+     * The bearer this client would send on its next authenticated request,
+     * for callers that open their own connection to the gateway (for example
+     * a native WebSocket). `force_refresh` bypasses any cached token; a
+     * static access token is returned as-is. The value is a raw token — the
+     * caller attaches it as `authorization: Bearer <token>`.
+     */
+    accessToken(forceRefresh: boolean, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<string>;
+    createClaim(request: CreateClaimRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    /**
+     * Fan out `create_claim` calls across the requested warm pools, tagging
+     * every claim with `cua.ai/fleet=<fleet_id>` so the group can be listed
+     * back later. Duplicate pool entries are aggregated before any network
+     * call. Claims are created sequentially; if one creation fails the error
+     * is returned immediately and claims already created keep their fleet
+     * label, so `list_fleet_claims` still finds them for retry or cleanup.
+     */
+    createFleetClaims(fleetId: string, requests: Array<FleetPoolRequest>, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<FleetClaims>;
+    createImage(namespace: string, manifest: PreservedJsonLike, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PreservedJsonLike>;
+    createNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Namespace>;
+    createPool(request: CreatePoolRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    /**
+     * Create (or replace) a `cua-registry-*` dockerconfigjson pull Secret.
+     * On a name conflict the old Secret is deleted and the new one created,
+     * since the gateway admits no Secret update.
+     */
+    createRegistrySecret(request: CreateRegistrySecretRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<RegistrySecret>;
+    createSignedServiceUrl(request: CreateSignedServiceUrlRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SignedServiceUrl>;
+    createTemplate(request: CreateTemplateRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    createUserApiKey(request: CreateUserApiKeyRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<NewUserApiKey>;
+    /**
+     * Delete the claim and, when it references a claim-scoped Secret
+     * (`secret_files`), that Secret too. The pool-operator also owner-refs
+     * the Secret to the claim, so garbage collection is the backstop.
+     */
+    deleteClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteImage(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deletePool(pool: Pool, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteRegistrySecret(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteTemplate(template: Template, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    deleteUserApiKey(id: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    getClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    getImage(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PreservedJsonLike>;
+    getNamespace(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Namespace>;
+    getPool(name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    getTemplate(namespace: string, name: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    listClaims(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Claim>>;
+    /**
+     * The fleet's claims within one namespace: enumerate the namespace's
+     * claims and keep those labeled `cua.ai/fleet=<fleet_id>`. A fleet that
+     * spans several pools spans that many namespaces (one pool per
+     * namespace), so call this once per member pool.
+     */
+    listFleetClaims(namespace: string, fleetId: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<FleetClaims>;
+    listImages(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<PreservedJsonLike>>;
+    listNamespaces(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Namespace>>;
+    listPools(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Pool>>;
+    listSignedServiceUrls(sandbox: Sandbox, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<SignedServiceUrl>>;
+    listTemplates(namespace: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Template>>;
+    listUserApiKeys(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<UserApiKey>>;
+    presignImageUploads(request: ImageUploadRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ImageUploadResponse>;
+    reconcilePool(request: CreatePoolRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    reconcileTemplate(request: CreateTemplateRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    /**
+     * Push the claim's `spec.lifecycle.shutdownTime` forward. That absolute
+     * expiry is the only liveness input the pool operator's claim reaper
+     * honors, so a holder that outlives its current lease must renew before
+     * the deadline passes or the bound sandbox is deleted underneath it.
+     * Deliberately narrower than a claim update: nothing else on the claim
+     * can be mutated through the SDK.
+     */
+    renewClaim(claim: Claim, shutdownTime: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Claim>;
+    /**
+     * Pin a public registry ref to a digest server-side. `runtime` (`gvisor`,
+     * `kubevirt`, `macos`) selects the variant for canonical cua images:
+     * `kubevirt` maps `ghcr.io/trycua/linux:24.04` to its `-disk` sibling.
+     */
+    resolveImage(reference: string, runtime: string | undefined, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ResolvedImage>;
+    revokeSignedServiceUrl(signedServiceUrl: SignedServiceUrl, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    serviceRequest(sandbox: Sandbox, service: string, path: string, request: HttpRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<HttpResponse>;
+    /**
+     * Where a native client opens its own WebSocket to a sandbox service:
+     * the gateway's `/api/svc` proxy forwards the HTTP upgrade, so the
+     * returned `ws(s)://` URL plus the returned bearer header are all a
+     * Rust or Swift caller needs to dial the socket directly.
+     * `service_request` stays the path for unary requests.
+     */
+    serviceWebsocketUrl(sandbox: Sandbox, service: string, path: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ServiceStreamTarget>;
+    updatePool(pool: Pool, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Pool>;
+    updateTemplate(template: Template, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Template>;
+    /**
+     * Hash and upload one file, or reuse a matching existing object.
+     * Returns only the bound digest, size, and tenant reference, never a signed URL.
+     * This does not create an Image or attest to object versioning/encryption.
+     */
+    uploadImageFile(namespace: string, name: string, contents: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ImageUploadInstruction>;
+    waitClaim(claim: Claim, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Sandbox>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CyclopsClient;
+}
+export interface CyclopsTokenProviderConfigurationBuilderLike {
+    baseUrl(value: string): CyclopsTokenProviderConfigurationBuilderLike;
+    build(): CyclopsTokenProviderConfiguration;
+    claimPollIntervalMs(value: bigint): CyclopsTokenProviderConfigurationBuilderLike;
+    claimPollLimit(value: number): CyclopsTokenProviderConfigurationBuilderLike;
+    poolPollIntervalMs(value: bigint): CyclopsTokenProviderConfigurationBuilderLike;
+    poolPollLimit(value: number): CyclopsTokenProviderConfigurationBuilderLike;
+}
+/**
+ * @deprecated Use `CyclopsTokenProviderConfigurationBuilderLike` instead.
+ */
+export type CyclopsTokenProviderConfigurationBuilderInterface = CyclopsTokenProviderConfigurationBuilderLike;
+export declare class CyclopsTokenProviderConfigurationBuilder extends UniffiAbstractObject implements CyclopsTokenProviderConfigurationBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "CyclopsTokenProviderConfigurationBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    baseUrl(value: string): CyclopsTokenProviderConfigurationBuilderLike;
+    build(): CyclopsTokenProviderConfiguration;
+    claimPollIntervalMs(value: bigint): CyclopsTokenProviderConfigurationBuilderLike;
+    claimPollLimit(value: number): CyclopsTokenProviderConfigurationBuilderLike;
+    poolPollIntervalMs(value: bigint): CyclopsTokenProviderConfigurationBuilderLike;
+    poolPollLimit(value: number): CyclopsTokenProviderConfigurationBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is CyclopsTokenProviderConfigurationBuilder;
+}
+export interface HttpClient {
+    /**
+     * Executes an HTTP request. Foreign implementations must enforce
+     * `request.max_response_bytes` while streaming the response body.
+     * Implementations must not follow redirects, retry requests, or add ambient
+     * authentication/cookies. Send only the supplied headers and body; signed
+     * upload requests also use this interface and must not leak credentials.
+     */
+    execute(request: HttpRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<HttpResponse>;
+}
+export declare class HttpClientImpl extends UniffiAbstractObject implements HttpClient {
+    readonly [uniffiTypeNameSymbol] = "HttpClientImpl";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    /**
+     * Executes an HTTP request. Foreign implementations must enforce
+     * `request.max_response_bytes` while streaming the response body.
+     * Implementations must not follow redirects, retry requests, or add ambient
+     * authentication/cookies. Send only the supplied headers and body; signed
+     * upload requests also use this interface and must not leak credentials.
+     */
+    execute(request: HttpRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<HttpResponse>;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is HttpClientImpl;
+}
+export interface HttpRequestBuilderLike {
+    body(value: ArrayBuffer): HttpRequestBuilderLike;
+    build(): HttpRequest;
+    headers(value: Array<HttpHeader>): HttpRequestBuilderLike;
+    maxResponseBytes(value: bigint): HttpRequestBuilderLike;
+    method(value: string): HttpRequestBuilderLike;
+    timeoutSecs(value: bigint): HttpRequestBuilderLike;
+    url(value: string): HttpRequestBuilderLike;
+}
+/**
+ * @deprecated Use `HttpRequestBuilderLike` instead.
+ */
+export type HttpRequestBuilderInterface = HttpRequestBuilderLike;
+export declare class HttpRequestBuilder extends UniffiAbstractObject implements HttpRequestBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "HttpRequestBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    body(value: ArrayBuffer): HttpRequestBuilderLike;
+    build(): HttpRequest;
+    headers(value: Array<HttpHeader>): HttpRequestBuilderLike;
+    maxResponseBytes(value: bigint): HttpRequestBuilderLike;
+    method(value: string): HttpRequestBuilderLike;
+    timeoutSecs(value: bigint): HttpRequestBuilderLike;
+    url(value: string): HttpRequestBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is HttpRequestBuilder;
+}
+export interface TemplateBuilderLike {
+    apiVersion(value: string): TemplateBuilderLike;
+    build(): Template;
+    kind(value: string): TemplateBuilderLike;
+    metadata(value: ResourceMetadata): TemplateBuilderLike;
+    spec(value: OsGymSandboxTemplateSpec): TemplateBuilderLike;
+}
+/**
+ * @deprecated Use `TemplateBuilderLike` instead.
+ */
+export type TemplateBuilderInterface = TemplateBuilderLike;
+export declare class TemplateBuilder extends UniffiAbstractObject implements TemplateBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "TemplateBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    apiVersion(value: string): TemplateBuilderLike;
+    build(): Template;
+    kind(value: string): TemplateBuilderLike;
+    metadata(value: ResourceMetadata): TemplateBuilderLike;
+    spec(value: OsGymSandboxTemplateSpec): TemplateBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is TemplateBuilder;
+}
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default: Readonly<{
+    initialize: typeof uniffiEnsureInitialized;
+    converters: {
+        FfiConverterTypeAccessTokenProvider: FfiConverterObjectWithCallbacks<AccessTokenProvider>;
+        FfiConverterTypeAccessTokenProviderError: {
+            read(from: RustBuffer): {
+                readonly tag: AccessTokenProviderError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: AccessTokenProviderError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: AccessTokenProviderError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: AccessTokenProviderError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: AccessTokenProviderError_Tags.Failed;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "AccessTokenProviderError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClaim: {
+            read(from: RustBuffer): Claim;
+            write(value: Claim, into: RustBuffer): void;
+            allocationSize(value: Claim): number;
+            lift(value: UniffiByteArray): Claim;
+            lower(value: Claim, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateClaimRequest: {
+            read(from: RustBuffer): CreateClaimRequest;
+            write(value: CreateClaimRequest, into: RustBuffer): void;
+            allocationSize(value: CreateClaimRequest): number;
+            lift(value: UniffiByteArray): CreateClaimRequest;
+            lower(value: CreateClaimRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateClaimRequestBuilder: FfiConverterObject<CreateClaimRequestBuilderLike>;
+        FfiConverterTypeCreatePoolRequest: {
+            read(from: RustBuffer): CreatePoolRequest;
+            write(value: CreatePoolRequest, into: RustBuffer): void;
+            allocationSize(value: CreatePoolRequest): number;
+            lift(value: UniffiByteArray): CreatePoolRequest;
+            lower(value: CreatePoolRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreatePoolRequestBuilder: FfiConverterObject<CreatePoolRequestBuilderLike>;
+        FfiConverterTypeCreateRegistrySecretRequest: {
+            read(from: RustBuffer): CreateRegistrySecretRequest;
+            write(value: CreateRegistrySecretRequest, into: RustBuffer): void;
+            allocationSize(value: CreateRegistrySecretRequest): number;
+            lift(value: UniffiByteArray): CreateRegistrySecretRequest;
+            lower(value: CreateRegistrySecretRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateRegistrySecretRequestBuilder: FfiConverterObject<CreateRegistrySecretRequestBuilderLike>;
+        FfiConverterTypeCreateSignedServiceUrlRequest: {
+            read(from: RustBuffer): CreateSignedServiceUrlRequest;
+            write(value: CreateSignedServiceUrlRequest, into: RustBuffer): void;
+            allocationSize(value: CreateSignedServiceUrlRequest): number;
+            lift(value: UniffiByteArray): CreateSignedServiceUrlRequest;
+            lower(value: CreateSignedServiceUrlRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateSignedServiceUrlRequestBuilder: FfiConverterObject<CreateSignedServiceUrlRequestBuilderLike>;
+        FfiConverterTypeCreateTemplateRequest: {
+            read(from: RustBuffer): CreateTemplateRequest;
+            write(value: CreateTemplateRequest, into: RustBuffer): void;
+            allocationSize(value: CreateTemplateRequest): number;
+            lift(value: UniffiByteArray): CreateTemplateRequest;
+            lower(value: CreateTemplateRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateTemplateRequestBuilder: FfiConverterObject<CreateTemplateRequestBuilderLike>;
+        FfiConverterTypeCreateUserApiKeyRequest: {
+            read(from: RustBuffer): CreateUserApiKeyRequest;
+            write(value: CreateUserApiKeyRequest, into: RustBuffer): void;
+            allocationSize(value: CreateUserApiKeyRequest): number;
+            lift(value: UniffiByteArray): CreateUserApiKeyRequest;
+            lower(value: CreateUserApiKeyRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCreateUserApiKeyRequestBuilder: FfiConverterObject<CreateUserApiKeyRequestBuilderLike>;
+        FfiConverterTypeCyclopsClient: FfiConverterObject<CyclopsClientLike>;
+        FfiConverterTypeCyclopsConfiguration: {
+            read(from: RustBuffer): CyclopsConfiguration;
+            write(value: CyclopsConfiguration, into: RustBuffer): void;
+            allocationSize(value: CyclopsConfiguration): number;
+            lift(value: UniffiByteArray): CyclopsConfiguration;
+            lower(value: CyclopsConfiguration, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCyclopsCredentials: FfiConverterObject<CyclopsCredentialsLike>;
+        FfiConverterTypeCyclopsTokenProviderConfiguration: {
+            read(from: RustBuffer): CyclopsTokenProviderConfiguration;
+            write(value: CyclopsTokenProviderConfiguration, into: RustBuffer): void;
+            allocationSize(value: CyclopsTokenProviderConfiguration): number;
+            lift(value: UniffiByteArray): CyclopsTokenProviderConfiguration;
+            lower(value: CyclopsTokenProviderConfiguration, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeCyclopsTokenProviderConfigurationBuilder: FfiConverterObject<CyclopsTokenProviderConfigurationBuilderLike>;
+        FfiConverterTypeFleetClaims: {
+            read(from: RustBuffer): FleetClaims;
+            write(value: FleetClaims, into: RustBuffer): void;
+            allocationSize(value: FleetClaims): number;
+            lift(value: UniffiByteArray): FleetClaims;
+            lower(value: FleetClaims, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeFleetPoolRequest: {
+            read(from: RustBuffer): FleetPoolRequest;
+            write(value: FleetPoolRequest, into: RustBuffer): void;
+            allocationSize(value: FleetPoolRequest): number;
+            lift(value: UniffiByteArray): FleetPoolRequest;
+            lower(value: FleetPoolRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeHttpClient: FfiConverterObjectWithCallbacks<HttpClient>;
+        FfiConverterTypeHttpError: {
+            read(from: RustBuffer): {
+                readonly tag: HttpError_Tags.Transport;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "HttpError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: HttpError_Tags.Transport;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "HttpError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: HttpError_Tags.Transport;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "HttpError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: HttpError_Tags.Transport;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "HttpError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: HttpError_Tags.Transport;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "HttpError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeHttpHeader: {
+            read(from: RustBuffer): HttpHeader;
+            write(value: HttpHeader, into: RustBuffer): void;
+            allocationSize(value: HttpHeader): number;
+            lift(value: UniffiByteArray): HttpHeader;
+            lower(value: HttpHeader, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeHttpRequest: {
+            read(from: RustBuffer): HttpRequest;
+            write(value: HttpRequest, into: RustBuffer): void;
+            allocationSize(value: HttpRequest): number;
+            lift(value: UniffiByteArray): HttpRequest;
+            lower(value: HttpRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeHttpRequestBuilder: FfiConverterObject<HttpRequestBuilderLike>;
+        FfiConverterTypeHttpResponse: {
+            read(from: RustBuffer): HttpResponse;
+            write(value: HttpResponse, into: RustBuffer): void;
+            allocationSize(value: HttpResponse): number;
+            lift(value: UniffiByteArray): HttpResponse;
+            lower(value: HttpResponse, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImageUploadFileRequest: {
+            read(from: RustBuffer): ImageUploadFileRequest;
+            write(value: ImageUploadFileRequest, into: RustBuffer): void;
+            allocationSize(value: ImageUploadFileRequest): number;
+            lift(value: UniffiByteArray): ImageUploadFileRequest;
+            lower(value: ImageUploadFileRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImageUploadInstruction: {
+            read(from: RustBuffer): ImageUploadInstruction;
+            write(value: ImageUploadInstruction, into: RustBuffer): void;
+            allocationSize(value: ImageUploadInstruction): number;
+            lift(value: UniffiByteArray): ImageUploadInstruction;
+            lower(value: ImageUploadInstruction, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImageUploadRequest: {
+            read(from: RustBuffer): ImageUploadRequest;
+            write(value: ImageUploadRequest, into: RustBuffer): void;
+            allocationSize(value: ImageUploadRequest): number;
+            lift(value: UniffiByteArray): ImageUploadRequest;
+            lower(value: ImageUploadRequest, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImageUploadResponse: {
+            read(from: RustBuffer): ImageUploadResponse;
+            write(value: ImageUploadResponse, into: RustBuffer): void;
+            allocationSize(value: ImageUploadResponse): number;
+            lift(value: UniffiByteArray): ImageUploadResponse;
+            lower(value: ImageUploadResponse, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeNamespace: {
+            read(from: RustBuffer): Namespace;
+            write(value: Namespace, into: RustBuffer): void;
+            allocationSize(value: Namespace): number;
+            lift(value: UniffiByteArray): Namespace;
+            lower(value: Namespace, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeNewUserApiKey: {
+            read(from: RustBuffer): NewUserApiKey;
+            write(value: NewUserApiKey, into: RustBuffer): void;
+            allocationSize(value: NewUserApiKey): number;
+            lift(value: UniffiByteArray): NewUserApiKey;
+            lower(value: NewUserApiKey, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePool: {
+            read(from: RustBuffer): Pool;
+            write(value: Pool, into: RustBuffer): void;
+            allocationSize(value: Pool): number;
+            lift(value: UniffiByteArray): Pool;
+            lower(value: Pool, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePoolDisplayStatus: {
+            read(from: RustBuffer): PoolDisplayStatus;
+            write(value: PoolDisplayStatus, into: RustBuffer): void;
+            allocationSize(value: PoolDisplayStatus): number;
+            lift(value: UniffiByteArray): PoolDisplayStatus;
+            lower(value: PoolDisplayStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePoolDisplayStatusKind: {
+            read(from: RustBuffer): PoolDisplayStatusKind;
+            write(value: PoolDisplayStatusKind, into: RustBuffer): void;
+            allocationSize(value: PoolDisplayStatusKind): number;
+            lift(value: UniffiByteArray): PoolDisplayStatusKind;
+            lower(value: PoolDisplayStatusKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePresignedPut: {
+            read(from: RustBuffer): PresignedPut;
+            write(value: PresignedPut, into: RustBuffer): void;
+            allocationSize(value: PresignedPut): number;
+            lift(value: UniffiByteArray): PresignedPut;
+            lower(value: PresignedPut, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeRegistrySecret: {
+            read(from: RustBuffer): RegistrySecret;
+            write(value: RegistrySecret, into: RustBuffer): void;
+            allocationSize(value: RegistrySecret): number;
+            lift(value: UniffiByteArray): RegistrySecret;
+            lower(value: RegistrySecret, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeResolvedImage: {
+            read(from: RustBuffer): ResolvedImage;
+            write(value: ResolvedImage, into: RustBuffer): void;
+            allocationSize(value: ResolvedImage): number;
+            lift(value: UniffiByteArray): ResolvedImage;
+            lower(value: ResolvedImage, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeResourceMetadata: {
+            read(from: RustBuffer): ResourceMetadata;
+            write(value: ResourceMetadata, into: RustBuffer): void;
+            allocationSize(value: ResourceMetadata): number;
+            lift(value: UniffiByteArray): ResourceMetadata;
+            lower(value: ResourceMetadata, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSandbox: {
+            read(from: RustBuffer): Sandbox;
+            write(value: Sandbox, into: RustBuffer): void;
+            allocationSize(value: Sandbox): number;
+            lift(value: UniffiByteArray): Sandbox;
+            lower(value: Sandbox, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSdkBuildError: {
+            read(from: RustBuffer): {
+                readonly tag: SdkBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: SdkBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: SdkBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: SdkBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: SdkBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SdkBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSdkError: {
+            read(from: RustBuffer): SdkError;
+            write(value: SdkError, into: RustBuffer): void;
+            allocationSize(value: SdkError): number;
+            lift(value: UniffiByteArray): SdkError;
+            lower(value: SdkError, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeServiceStreamTarget: {
+            read(from: RustBuffer): ServiceStreamTarget;
+            write(value: ServiceStreamTarget, into: RustBuffer): void;
+            allocationSize(value: ServiceStreamTarget): number;
+            lift(value: UniffiByteArray): ServiceStreamTarget;
+            lower(value: ServiceStreamTarget, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSignedServiceUrl: {
+            read(from: RustBuffer): SignedServiceUrl;
+            write(value: SignedServiceUrl, into: RustBuffer): void;
+            allocationSize(value: SignedServiceUrl): number;
+            lift(value: UniffiByteArray): SignedServiceUrl;
+            lower(value: SignedServiceUrl, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeTemplate: {
+            read(from: RustBuffer): Template;
+            write(value: Template, into: RustBuffer): void;
+            allocationSize(value: Template): number;
+            lift(value: UniffiByteArray): Template;
+            lower(value: Template, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeTemplateBuilder: FfiConverterObject<TemplateBuilderLike>;
+        FfiConverterTypeUserApiKey: {
+            read(from: RustBuffer): UserApiKey;
+            write(value: UserApiKey, into: RustBuffer): void;
+            allocationSize(value: UserApiKey): number;
+            lift(value: UniffiByteArray): UserApiKey;
+            lower(value: UserApiKey, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;