@trycua/cua 0.2.0

package/browser/cyclops_sdk_schema.d.ts

@@ -0,0 +1,996 @@
+import { type UniffiByteArray, type UniffiGcObject, type UniffiHandle, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "@ubjs/core";
+export type ClaimLifecycle = {
+    shutdownTime?: string;
+    shutdownPolicy?: string;
+    autoRenew?: boolean;
+};
+/**
+ * Generated factory for {@link ClaimLifecycle} record objects.
+ */
+export declare const ClaimLifecycle: Readonly<{
+    create: (partial: Partial<ClaimLifecycle> & Required<Omit<ClaimLifecycle, "shutdownTime" | "shutdownPolicy" | "autoRenew">>) => ClaimLifecycle;
+    new: (partial: Partial<ClaimLifecycle> & Required<Omit<ClaimLifecycle, "shutdownTime" | "shutdownPolicy" | "autoRenew">>) => ClaimLifecycle;
+    defaults: () => Partial<ClaimLifecycle>;
+}>;
+/**
+ * Reference to a claim-scoped Secret delivered into the bound sandbox. See
+ * [`CLAIM_SECRET_NAME_PREFIX`].
+ */
+export type ClaimSecretRef = {
+    name: string;
+};
+/**
+ * Generated factory for {@link ClaimSecretRef} record objects.
+ */
+export declare const ClaimSecretRef: Readonly<{
+    create: (partial: Partial<ClaimSecretRef> & Required<Omit<ClaimSecretRef, "name">>) => ClaimSecretRef;
+    new: (partial: Partial<ClaimSecretRef> & Required<Omit<ClaimSecretRef, "name">>) => ClaimSecretRef;
+    defaults: () => Partial<ClaimSecretRef>;
+}>;
+export type SandboxTemplateRef = {
+    name: string;
+};
+/**
+ * Generated factory for {@link SandboxTemplateRef} record objects.
+ */
+export declare const SandboxTemplateRef: Readonly<{
+    create: (partial: Partial<SandboxTemplateRef> & Required<Omit<SandboxTemplateRef, "name">>) => SandboxTemplateRef;
+    new: (partial: Partial<SandboxTemplateRef> & Required<Omit<SandboxTemplateRef, "name">>) => SandboxTemplateRef;
+    defaults: () => Partial<SandboxTemplateRef>;
+}>;
+export type ClaimSpec = {
+    sandboxTemplateRef: SandboxTemplateRef;
+    warmpool?: string;
+    bindDeadline?: number;
+    lifecycle?: ClaimLifecycle;
+    ttlSecondsAfterCreated?: number;
+    secretRef?: ClaimSecretRef;
+};
+/**
+ * Generated factory for {@link ClaimSpec} record objects.
+ */
+export declare const ClaimSpec: Readonly<{
+    create: (partial: Partial<ClaimSpec> & Required<Omit<ClaimSpec, "sandboxTemplateRef" | "warmpool" | "bindDeadline" | "lifecycle" | "ttlSecondsAfterCreated" | "secretRef">>) => ClaimSpec;
+    new: (partial: Partial<ClaimSpec> & Required<Omit<ClaimSpec, "sandboxTemplateRef" | "warmpool" | "bindDeadline" | "lifecycle" | "ttlSecondsAfterCreated" | "secretRef">>) => ClaimSpec;
+    defaults: () => Partial<ClaimSpec>;
+}>;
+export type OsGymSandboxClaimCondition = {
+    type?: string;
+    status?: string;
+    reason?: string;
+    message?: string;
+    lastTransitionTime?: string;
+};
+/**
+ * Generated factory for {@link OsGymSandboxClaimCondition} record objects.
+ */
+export declare const OsGymSandboxClaimCondition: Readonly<{
+    create: (partial: Partial<OsGymSandboxClaimCondition> & Required<Omit<OsGymSandboxClaimCondition, "reason" | "type" | "status" | "message" | "lastTransitionTime">>) => OsGymSandboxClaimCondition;
+    new: (partial: Partial<OsGymSandboxClaimCondition> & Required<Omit<OsGymSandboxClaimCondition, "reason" | "type" | "status" | "message" | "lastTransitionTime">>) => OsGymSandboxClaimCondition;
+    defaults: () => Partial<OsGymSandboxClaimCondition>;
+}>;
+export type OsGymSandboxClaimSandbox = {
+    name?: string;
+    service?: string;
+};
+/**
+ * Generated factory for {@link OsGymSandboxClaimSandbox} record objects.
+ */
+export declare const OsGymSandboxClaimSandbox: Readonly<{
+    create: (partial: Partial<OsGymSandboxClaimSandbox> & Required<Omit<OsGymSandboxClaimSandbox, "name" | "service">>) => OsGymSandboxClaimSandbox;
+    new: (partial: Partial<OsGymSandboxClaimSandbox> & Required<Omit<OsGymSandboxClaimSandbox, "name" | "service">>) => OsGymSandboxClaimSandbox;
+    defaults: () => Partial<OsGymSandboxClaimSandbox>;
+}>;
+export type OsGymSandboxClaimStatus = {
+    phase?: string;
+    conditions?: Array<OsGymSandboxClaimCondition>;
+    sandbox?: OsGymSandboxClaimSandbox;
+};
+/**
+ * Generated factory for {@link OsGymSandboxClaimStatus} record objects.
+ */
+export declare const OsGymSandboxClaimStatus: Readonly<{
+    create: (partial: Partial<OsGymSandboxClaimStatus> & Required<Omit<OsGymSandboxClaimStatus, "phase" | "conditions" | "sandbox">>) => OsGymSandboxClaimStatus;
+    new: (partial: Partial<OsGymSandboxClaimStatus> & Required<Omit<OsGymSandboxClaimStatus, "phase" | "conditions" | "sandbox">>) => OsGymSandboxClaimStatus;
+    defaults: () => Partial<OsGymSandboxClaimStatus>;
+}>;
+export declare enum RuntimeKind {
+    Kubevirt = 0,
+    Macos = 1,
+    Gvisor = 2
+}
+export interface PreservedJsonLike {
+    toJson(): string;
+}
+/**
+ * @deprecated Use `PreservedJsonLike` instead.
+ */
+export type PreservedJsonInterface = PreservedJsonLike;
+export declare class PreservedJson extends UniffiAbstractObject implements PreservedJsonLike {
+    readonly [uniffiTypeNameSymbol] = "PreservedJson";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    private constructor();
+    static fromJson(value: string): PreservedJsonLike;
+    toJson(): string;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is PreservedJson;
+}
+export declare enum ImagePullPolicy {
+    Always = 0,
+    IfNotPresent = 1,
+    Never = 2
+}
+export declare enum Firmware {
+    Bios = 0,
+    Efi = 1
+}
+export declare enum ServiceProtocol {
+    Tcp = 0,
+    Udp = 1
+}
+export type SandboxService = {
+    name: string;
+    targetPort: number;
+    protocol?: ServiceProtocol;
+};
+/**
+ * Generated factory for {@link SandboxService} record objects.
+ */
+export declare const SandboxService: Readonly<{
+    create: (partial: Partial<SandboxService> & Required<Omit<SandboxService, "name" | "targetPort" | "protocol">>) => SandboxService;
+    new: (partial: Partial<SandboxService> & Required<Omit<SandboxService, "name" | "targetPort" | "protocol">>) => SandboxService;
+    defaults: () => Partial<SandboxService>;
+}>;
+export type OidcConfig = {
+    credentialsSecret: string;
+    tokenUrl: string;
+    awsRoleArn?: string;
+    awsRegion?: string;
+    refreshIntervalSeconds?: number;
+};
+/**
+ * Generated factory for {@link OidcConfig} record objects.
+ */
+export declare const OidcConfig: Readonly<{
+    create: (partial: Partial<OidcConfig> & Required<Omit<OidcConfig, "credentialsSecret" | "tokenUrl" | "awsRoleArn" | "awsRegion" | "refreshIntervalSeconds">>) => OidcConfig;
+    new: (partial: Partial<OidcConfig> & Required<Omit<OidcConfig, "credentialsSecret" | "tokenUrl" | "awsRoleArn" | "awsRegion" | "refreshIntervalSeconds">>) => OidcConfig;
+    defaults: () => Partial<OidcConfig>;
+}>;
+/**
+ * How `vmTemplate.command`/`args`/`env` reach the sandbox
+ * (`vmTemplate.processMode`). Absent means `Legacy`.
+ */
+export declare enum ProcessMode {
+    /**
+     * What templates did before processMode existed: pod runtimes run
+     * command/args/env; KubeVirt ignores command and refuses args/env.
+     */
+    Legacy = 0,
+    /**
+     * Every runtime runs command/args/env. Pod runtimes set them on the
+     * sandbox container; KubeVirt renders them into the sandbox's cloud-init.
+     */
+    Run = 1
+}
+export type VmTemplate = {
+    containerDiskImage: string;
+    command?: Array<string>;
+    runtime?: RuntimeKind;
+    runtimeClassName?: string;
+    nodeSelector?: Map<string, string>;
+    tolerations?: Array<PreservedJsonLike>;
+    imagePullPolicy?: ImagePullPolicy;
+    imagePullSecret?: string;
+    cpuCores?: number;
+    memory?: string;
+    firmware?: Firmware;
+    nestedVirtualization?: boolean;
+    probes?: PreservedJsonLike;
+    services?: Array<SandboxService>;
+    oidc?: OidcConfig;
+    claimSecrets?: boolean;
+    args?: Array<string>;
+    env?: Map<string, string>;
+    processMode?: ProcessMode;
+};
+/**
+ * Generated factory for {@link VmTemplate} record objects.
+ */
+export declare const VmTemplate: Readonly<{
+    create: (partial: Partial<VmTemplate> & Required<Omit<VmTemplate, "services" | "args" | "env" | "containerDiskImage" | "command" | "runtime" | "runtimeClassName" | "nodeSelector" | "tolerations" | "imagePullPolicy" | "imagePullSecret" | "cpuCores" | "memory" | "firmware" | "nestedVirtualization" | "probes" | "oidc" | "claimSecrets" | "processMode">>) => VmTemplate;
+    new: (partial: Partial<VmTemplate> & Required<Omit<VmTemplate, "services" | "args" | "env" | "containerDiskImage" | "command" | "runtime" | "runtimeClassName" | "nodeSelector" | "tolerations" | "imagePullPolicy" | "imagePullSecret" | "cpuCores" | "memory" | "firmware" | "nestedVirtualization" | "probes" | "oidc" | "claimSecrets" | "processMode">>) => VmTemplate;
+    defaults: () => Partial<VmTemplate>;
+}>;
+export type OsGymSandboxSpec = {
+    vmTemplate: VmTemplate;
+};
+/**
+ * Generated factory for {@link OsGymSandboxSpec} record objects.
+ */
+export declare const OsGymSandboxSpec: Readonly<{
+    create: (partial: Partial<OsGymSandboxSpec> & Required<Omit<OsGymSandboxSpec, "vmTemplate">>) => OsGymSandboxSpec;
+    new: (partial: Partial<OsGymSandboxSpec> & Required<Omit<OsGymSandboxSpec, "vmTemplate">>) => OsGymSandboxSpec;
+    defaults: () => Partial<OsGymSandboxSpec>;
+}>;
+export type OsGymSandboxStatus = {
+    phase?: string;
+    runtime?: string;
+    ready?: boolean;
+    vmName?: string;
+    service?: string;
+    message?: string;
+    resetIssuedAt?: string;
+    resetVmiUid?: string;
+};
+/**
+ * Generated factory for {@link OsGymSandboxStatus} record objects.
+ */
+export declare const OsGymSandboxStatus: Readonly<{
+    create: (partial: Partial<OsGymSandboxStatus> & Required<Omit<OsGymSandboxStatus, "message" | "service" | "phase" | "runtime" | "ready" | "vmName" | "resetIssuedAt" | "resetVmiUid">>) => OsGymSandboxStatus;
+    new: (partial: Partial<OsGymSandboxStatus> & Required<Omit<OsGymSandboxStatus, "message" | "service" | "phase" | "runtime" | "ready" | "vmName" | "resetIssuedAt" | "resetVmiUid">>) => OsGymSandboxStatus;
+    defaults: () => Partial<OsGymSandboxStatus>;
+}>;
+export type OsGymSandboxTemplateSpec = {
+    vmTemplate: VmTemplate;
+};
+/**
+ * Generated factory for {@link OsGymSandboxTemplateSpec} record objects.
+ */
+export declare const OsGymSandboxTemplateSpec: Readonly<{
+    create: (partial: Partial<OsGymSandboxTemplateSpec> & Required<Omit<OsGymSandboxTemplateSpec, "vmTemplate">>) => OsGymSandboxTemplateSpec;
+    new: (partial: Partial<OsGymSandboxTemplateSpec> & Required<Omit<OsGymSandboxTemplateSpec, "vmTemplate">>) => OsGymSandboxTemplateSpec;
+    defaults: () => Partial<OsGymSandboxTemplateSpec>;
+}>;
+export type WarmPoolAutoscaling = {
+    minPoolSize?: number;
+    initialPoolSize?: number;
+    maxPoolSize?: number;
+};
+/**
+ * Generated factory for {@link WarmPoolAutoscaling} record objects.
+ */
+export declare const WarmPoolAutoscaling: Readonly<{
+    create: (partial: Partial<WarmPoolAutoscaling> & Required<Omit<WarmPoolAutoscaling, "minPoolSize" | "initialPoolSize" | "maxPoolSize">>) => WarmPoolAutoscaling;
+    new: (partial: Partial<WarmPoolAutoscaling> & Required<Omit<WarmPoolAutoscaling, "minPoolSize" | "initialPoolSize" | "maxPoolSize">>) => WarmPoolAutoscaling;
+    defaults: () => Partial<WarmPoolAutoscaling>;
+}>;
+/**
+ * What the pool-operator deletes when a warm pool's creation TTL
+ * (`ttlSecondsAfterCreated`) or idle TTL (`idleTtlSeconds`) expires.
+ */
+export declare enum WarmPoolTtlPolicy {
+    /**
+     * Delete only the warm pool. Its claims and namespace stay.
+     */
+    Retain = 0,
+    /**
+     * Also delete the pool's dead unbound claims (TTL passed, older than
+     * max(900s, bindDeadline)). Bound claims, the namespace and volumes stay.
+     */
+    Cascade = 1
+}
+export type OsGymSandboxWarmPoolSpec = {
+    replicas: number;
+    sandboxTemplateRef: SandboxTemplateRef;
+    autoscaling?: WarmPoolAutoscaling;
+    ttlSecondsAfterCreated?: number;
+    idleTtlSeconds?: number;
+    ttlPolicy?: WarmPoolTtlPolicy;
+};
+/**
+ * Generated factory for {@link OsGymSandboxWarmPoolSpec} record objects.
+ */
+export declare const OsGymSandboxWarmPoolSpec: Readonly<{
+    create: (partial: Partial<OsGymSandboxWarmPoolSpec> & Required<Omit<OsGymSandboxWarmPoolSpec, "sandboxTemplateRef" | "ttlSecondsAfterCreated" | "replicas" | "autoscaling" | "idleTtlSeconds" | "ttlPolicy">>) => OsGymSandboxWarmPoolSpec;
+    new: (partial: Partial<OsGymSandboxWarmPoolSpec> & Required<Omit<OsGymSandboxWarmPoolSpec, "sandboxTemplateRef" | "ttlSecondsAfterCreated" | "replicas" | "autoscaling" | "idleTtlSeconds" | "ttlPolicy">>) => OsGymSandboxWarmPoolSpec;
+    defaults: () => Partial<OsGymSandboxWarmPoolSpec>;
+}>;
+export type OsGymSandboxWarmPoolStatus = {
+    replicas?: number;
+    readyReplicas?: number;
+    selector?: string;
+    lastClaimedAt?: string;
+    lastActivityTime?: string;
+};
+/**
+ * Generated factory for {@link OsGymSandboxWarmPoolStatus} record objects.
+ */
+export declare const OsGymSandboxWarmPoolStatus: Readonly<{
+    create: (partial: Partial<OsGymSandboxWarmPoolStatus> & Required<Omit<OsGymSandboxWarmPoolStatus, "replicas" | "readyReplicas" | "selector" | "lastClaimedAt" | "lastActivityTime">>) => OsGymSandboxWarmPoolStatus;
+    new: (partial: Partial<OsGymSandboxWarmPoolStatus> & Required<Omit<OsGymSandboxWarmPoolStatus, "replicas" | "readyReplicas" | "selector" | "lastClaimedAt" | "lastActivityTime">>) => OsGymSandboxWarmPoolStatus;
+    defaults: () => Partial<OsGymSandboxWarmPoolStatus>;
+}>;
+export declare enum JsonValueError_Tags {
+    Invalid = "Invalid"
+}
+export declare const JsonValueError: Readonly<{
+    instanceOf: (obj: any) => obj is JsonValueError;
+    Invalid: {
+        new (inner: {
+            reason: string;
+        }): {
+            readonly tag: JsonValueError_Tags.Invalid;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "JsonValueError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            reason: string;
+        }): {
+            readonly tag: JsonValueError_Tags.Invalid;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "JsonValueError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: JsonValueError_Tags.Invalid;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "JsonValueError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: JsonValueError_Tags.Invalid;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "JsonValueError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: JsonValueError_Tags.Invalid;
+            readonly inner: Readonly<{
+                reason: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "JsonValueError";
+            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 JsonValueError = InstanceType<typeof JsonValueError['Invalid']>;
+export declare enum SchemaBuildError_Tags {
+    MissingRequiredField = "MissingRequiredField"
+}
+export declare const SchemaBuildError: Readonly<{
+    instanceOf: (obj: any) => obj is SchemaBuildError;
+    MissingRequiredField: {
+        new (inner: {
+            recordType: string;
+            field: string;
+        }): {
+            readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            recordType: string;
+            field: string;
+        }): {
+            readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+            readonly inner: Readonly<{
+                recordType: string;
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+            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 SchemaBuildError = InstanceType<typeof SchemaBuildError['MissingRequiredField']>;
+export interface OsGymSandboxTemplateSpecBuilderLike {
+    build(): OsGymSandboxTemplateSpec;
+    vmTemplate(value: VmTemplate): OsGymSandboxTemplateSpecBuilderLike;
+}
+/**
+ * @deprecated Use `OsGymSandboxTemplateSpecBuilderLike` instead.
+ */
+export type OsGymSandboxTemplateSpecBuilderInterface = OsGymSandboxTemplateSpecBuilderLike;
+export declare class OsGymSandboxTemplateSpecBuilder extends UniffiAbstractObject implements OsGymSandboxTemplateSpecBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "OsGymSandboxTemplateSpecBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): OsGymSandboxTemplateSpec;
+    vmTemplate(value: VmTemplate): OsGymSandboxTemplateSpecBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is OsGymSandboxTemplateSpecBuilder;
+}
+export interface OsGymSandboxWarmPoolSpecBuilderLike {
+    autoscaling(value: WarmPoolAutoscaling): OsGymSandboxWarmPoolSpecBuilderLike;
+    build(): OsGymSandboxWarmPoolSpec;
+    idleTtlSeconds(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+    replicas(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+    sandboxTemplateRef(value: SandboxTemplateRef): OsGymSandboxWarmPoolSpecBuilderLike;
+    ttlPolicy(value: WarmPoolTtlPolicy): OsGymSandboxWarmPoolSpecBuilderLike;
+    ttlSecondsAfterCreated(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+}
+/**
+ * @deprecated Use `OsGymSandboxWarmPoolSpecBuilderLike` instead.
+ */
+export type OsGymSandboxWarmPoolSpecBuilderInterface = OsGymSandboxWarmPoolSpecBuilderLike;
+export declare class OsGymSandboxWarmPoolSpecBuilder extends UniffiAbstractObject implements OsGymSandboxWarmPoolSpecBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "OsGymSandboxWarmPoolSpecBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    autoscaling(value: WarmPoolAutoscaling): OsGymSandboxWarmPoolSpecBuilderLike;
+    build(): OsGymSandboxWarmPoolSpec;
+    idleTtlSeconds(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+    replicas(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+    sandboxTemplateRef(value: SandboxTemplateRef): OsGymSandboxWarmPoolSpecBuilderLike;
+    ttlPolicy(value: WarmPoolTtlPolicy): OsGymSandboxWarmPoolSpecBuilderLike;
+    ttlSecondsAfterCreated(value: number): OsGymSandboxWarmPoolSpecBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is OsGymSandboxWarmPoolSpecBuilder;
+}
+export interface SandboxServiceBuilderLike {
+    build(): SandboxService;
+    name(value: string): SandboxServiceBuilderLike;
+    protocol(value: ServiceProtocol): SandboxServiceBuilderLike;
+    targetPort(value: number): SandboxServiceBuilderLike;
+}
+/**
+ * @deprecated Use `SandboxServiceBuilderLike` instead.
+ */
+export type SandboxServiceBuilderInterface = SandboxServiceBuilderLike;
+export declare class SandboxServiceBuilder extends UniffiAbstractObject implements SandboxServiceBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "SandboxServiceBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): SandboxService;
+    name(value: string): SandboxServiceBuilderLike;
+    protocol(value: ServiceProtocol): SandboxServiceBuilderLike;
+    targetPort(value: number): SandboxServiceBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is SandboxServiceBuilder;
+}
+export interface SandboxTemplateRefBuilderLike {
+    build(): SandboxTemplateRef;
+    name(value: string): SandboxTemplateRefBuilderLike;
+}
+/**
+ * @deprecated Use `SandboxTemplateRefBuilderLike` instead.
+ */
+export type SandboxTemplateRefBuilderInterface = SandboxTemplateRefBuilderLike;
+export declare class SandboxTemplateRefBuilder extends UniffiAbstractObject implements SandboxTemplateRefBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "SandboxTemplateRefBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): SandboxTemplateRef;
+    name(value: string): SandboxTemplateRefBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is SandboxTemplateRefBuilder;
+}
+export interface VmTemplateBuilderLike {
+    args(value: Array<string>): VmTemplateBuilderLike;
+    build(): VmTemplate;
+    claimSecrets(value: boolean): VmTemplateBuilderLike;
+    command(value: Array<string>): VmTemplateBuilderLike;
+    containerDiskImage(value: string): VmTemplateBuilderLike;
+    cpuCores(value: number): VmTemplateBuilderLike;
+    env(value: Map<string, string>): VmTemplateBuilderLike;
+    firmware(value: Firmware): VmTemplateBuilderLike;
+    imagePullPolicy(value: ImagePullPolicy): VmTemplateBuilderLike;
+    imagePullSecret(value: string): VmTemplateBuilderLike;
+    memory(value: string): VmTemplateBuilderLike;
+    nestedVirtualization(value: boolean): VmTemplateBuilderLike;
+    nodeSelector(value: Map<string, string>): VmTemplateBuilderLike;
+    oidc(value: OidcConfig): VmTemplateBuilderLike;
+    probes(value: PreservedJsonLike): VmTemplateBuilderLike;
+    processMode(value: ProcessMode): VmTemplateBuilderLike;
+    runtime(value: RuntimeKind): VmTemplateBuilderLike;
+    runtimeClassName(value: string): VmTemplateBuilderLike;
+    services(value: Array<SandboxService>): VmTemplateBuilderLike;
+    tolerations(value: Array<PreservedJsonLike>): VmTemplateBuilderLike;
+}
+/**
+ * @deprecated Use `VmTemplateBuilderLike` instead.
+ */
+export type VmTemplateBuilderInterface = VmTemplateBuilderLike;
+export declare class VmTemplateBuilder extends UniffiAbstractObject implements VmTemplateBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "VmTemplateBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    args(value: Array<string>): VmTemplateBuilderLike;
+    build(): VmTemplate;
+    claimSecrets(value: boolean): VmTemplateBuilderLike;
+    command(value: Array<string>): VmTemplateBuilderLike;
+    containerDiskImage(value: string): VmTemplateBuilderLike;
+    cpuCores(value: number): VmTemplateBuilderLike;
+    env(value: Map<string, string>): VmTemplateBuilderLike;
+    firmware(value: Firmware): VmTemplateBuilderLike;
+    imagePullPolicy(value: ImagePullPolicy): VmTemplateBuilderLike;
+    imagePullSecret(value: string): VmTemplateBuilderLike;
+    memory(value: string): VmTemplateBuilderLike;
+    nestedVirtualization(value: boolean): VmTemplateBuilderLike;
+    nodeSelector(value: Map<string, string>): VmTemplateBuilderLike;
+    oidc(value: OidcConfig): VmTemplateBuilderLike;
+    probes(value: PreservedJsonLike): VmTemplateBuilderLike;
+    processMode(value: ProcessMode): VmTemplateBuilderLike;
+    runtime(value: RuntimeKind): VmTemplateBuilderLike;
+    runtimeClassName(value: string): VmTemplateBuilderLike;
+    services(value: Array<SandboxService>): VmTemplateBuilderLike;
+    tolerations(value: Array<PreservedJsonLike>): VmTemplateBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is VmTemplateBuilder;
+}
+export interface WarmPoolAutoscalingBuilderLike {
+    build(): WarmPoolAutoscaling;
+    initialPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+    maxPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+    minPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+}
+/**
+ * @deprecated Use `WarmPoolAutoscalingBuilderLike` instead.
+ */
+export type WarmPoolAutoscalingBuilderInterface = WarmPoolAutoscalingBuilderLike;
+export declare class WarmPoolAutoscalingBuilder extends UniffiAbstractObject implements WarmPoolAutoscalingBuilderLike {
+    readonly [uniffiTypeNameSymbol] = "WarmPoolAutoscalingBuilder";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    constructor();
+    build(): WarmPoolAutoscaling;
+    initialPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+    maxPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+    minPoolSize(value: number): WarmPoolAutoscalingBuilderLike;
+    uniffiDestroy(): void;
+    static instanceOf(obj_: any): obj_ is WarmPoolAutoscalingBuilder;
+}
+/**
+ * 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: {
+        FfiConverterTypeClaimLifecycle: {
+            read(from: RustBuffer): ClaimLifecycle;
+            write(value: ClaimLifecycle, into: RustBuffer): void;
+            allocationSize(value: ClaimLifecycle): number;
+            lift(value: UniffiByteArray): ClaimLifecycle;
+            lower(value: ClaimLifecycle, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClaimSecretRef: {
+            read(from: RustBuffer): ClaimSecretRef;
+            write(value: ClaimSecretRef, into: RustBuffer): void;
+            allocationSize(value: ClaimSecretRef): number;
+            lift(value: UniffiByteArray): ClaimSecretRef;
+            lower(value: ClaimSecretRef, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeClaimSpec: {
+            read(from: RustBuffer): ClaimSpec;
+            write(value: ClaimSpec, into: RustBuffer): void;
+            allocationSize(value: ClaimSpec): number;
+            lift(value: UniffiByteArray): ClaimSpec;
+            lower(value: ClaimSpec, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeFirmware: {
+            read(from: RustBuffer): Firmware;
+            write(value: Firmware, into: RustBuffer): void;
+            allocationSize(value: Firmware): number;
+            lift(value: UniffiByteArray): Firmware;
+            lower(value: Firmware, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeImagePullPolicy: {
+            read(from: RustBuffer): ImagePullPolicy;
+            write(value: ImagePullPolicy, into: RustBuffer): void;
+            allocationSize(value: ImagePullPolicy): number;
+            lift(value: UniffiByteArray): ImagePullPolicy;
+            lower(value: ImagePullPolicy, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeJsonValueError: {
+            read(from: RustBuffer): {
+                readonly tag: JsonValueError_Tags.Invalid;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "JsonValueError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: JsonValueError_Tags.Invalid;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "JsonValueError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: JsonValueError_Tags.Invalid;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "JsonValueError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: JsonValueError_Tags.Invalid;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "JsonValueError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: JsonValueError_Tags.Invalid;
+                readonly inner: Readonly<{
+                    reason: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "JsonValueError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxClaimCondition: {
+            read(from: RustBuffer): OsGymSandboxClaimCondition;
+            write(value: OsGymSandboxClaimCondition, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxClaimCondition): number;
+            lift(value: UniffiByteArray): OsGymSandboxClaimCondition;
+            lower(value: OsGymSandboxClaimCondition, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxClaimSandbox: {
+            read(from: RustBuffer): OsGymSandboxClaimSandbox;
+            write(value: OsGymSandboxClaimSandbox, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxClaimSandbox): number;
+            lift(value: UniffiByteArray): OsGymSandboxClaimSandbox;
+            lower(value: OsGymSandboxClaimSandbox, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxClaimStatus: {
+            read(from: RustBuffer): OsGymSandboxClaimStatus;
+            write(value: OsGymSandboxClaimStatus, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxClaimStatus): number;
+            lift(value: UniffiByteArray): OsGymSandboxClaimStatus;
+            lower(value: OsGymSandboxClaimStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxSpec: {
+            read(from: RustBuffer): OsGymSandboxSpec;
+            write(value: OsGymSandboxSpec, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxSpec): number;
+            lift(value: UniffiByteArray): OsGymSandboxSpec;
+            lower(value: OsGymSandboxSpec, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxStatus: {
+            read(from: RustBuffer): OsGymSandboxStatus;
+            write(value: OsGymSandboxStatus, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxStatus): number;
+            lift(value: UniffiByteArray): OsGymSandboxStatus;
+            lower(value: OsGymSandboxStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxTemplateSpec: {
+            read(from: RustBuffer): OsGymSandboxTemplateSpec;
+            write(value: OsGymSandboxTemplateSpec, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxTemplateSpec): number;
+            lift(value: UniffiByteArray): OsGymSandboxTemplateSpec;
+            lower(value: OsGymSandboxTemplateSpec, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxTemplateSpecBuilder: FfiConverterObject<OsGymSandboxTemplateSpecBuilderLike>;
+        FfiConverterTypeOSGymSandboxWarmPoolSpec: {
+            read(from: RustBuffer): OsGymSandboxWarmPoolSpec;
+            write(value: OsGymSandboxWarmPoolSpec, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxWarmPoolSpec): number;
+            lift(value: UniffiByteArray): OsGymSandboxWarmPoolSpec;
+            lower(value: OsGymSandboxWarmPoolSpec, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder: FfiConverterObject<OsGymSandboxWarmPoolSpecBuilderLike>;
+        FfiConverterTypeOSGymSandboxWarmPoolStatus: {
+            read(from: RustBuffer): OsGymSandboxWarmPoolStatus;
+            write(value: OsGymSandboxWarmPoolStatus, into: RustBuffer): void;
+            allocationSize(value: OsGymSandboxWarmPoolStatus): number;
+            lift(value: UniffiByteArray): OsGymSandboxWarmPoolStatus;
+            lower(value: OsGymSandboxWarmPoolStatus, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeOidcConfig: {
+            read(from: RustBuffer): OidcConfig;
+            write(value: OidcConfig, into: RustBuffer): void;
+            allocationSize(value: OidcConfig): number;
+            lift(value: UniffiByteArray): OidcConfig;
+            lower(value: OidcConfig, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypePreservedJson: FfiConverterObject<PreservedJsonLike>;
+        FfiConverterTypeProcessMode: {
+            read(from: RustBuffer): ProcessMode;
+            write(value: ProcessMode, into: RustBuffer): void;
+            allocationSize(value: ProcessMode): number;
+            lift(value: UniffiByteArray): ProcessMode;
+            lower(value: ProcessMode, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeRuntimeKind: {
+            read(from: RustBuffer): RuntimeKind;
+            write(value: RuntimeKind, into: RustBuffer): void;
+            allocationSize(value: RuntimeKind): number;
+            lift(value: UniffiByteArray): RuntimeKind;
+            lower(value: RuntimeKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSandboxService: {
+            read(from: RustBuffer): SandboxService;
+            write(value: SandboxService, into: RustBuffer): void;
+            allocationSize(value: SandboxService): number;
+            lift(value: UniffiByteArray): SandboxService;
+            lower(value: SandboxService, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSandboxServiceBuilder: FfiConverterObject<SandboxServiceBuilderLike>;
+        FfiConverterTypeSandboxTemplateRef: {
+            read(from: RustBuffer): SandboxTemplateRef;
+            write(value: SandboxTemplateRef, into: RustBuffer): void;
+            allocationSize(value: SandboxTemplateRef): number;
+            lift(value: UniffiByteArray): SandboxTemplateRef;
+            lower(value: SandboxTemplateRef, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeSandboxTemplateRefBuilder: FfiConverterObject<SandboxTemplateRefBuilderLike>;
+        FfiConverterTypeSchemaBuildError: {
+            read(from: RustBuffer): {
+                readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: SchemaBuildError_Tags.MissingRequiredField;
+                readonly inner: Readonly<{
+                    recordType: string;
+                    field: string;
+                }>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "SchemaBuildError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeServiceProtocol: {
+            read(from: RustBuffer): ServiceProtocol;
+            write(value: ServiceProtocol, into: RustBuffer): void;
+            allocationSize(value: ServiceProtocol): number;
+            lift(value: UniffiByteArray): ServiceProtocol;
+            lower(value: ServiceProtocol, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVmTemplate: {
+            read(from: RustBuffer): VmTemplate;
+            write(value: VmTemplate, into: RustBuffer): void;
+            allocationSize(value: VmTemplate): number;
+            lift(value: UniffiByteArray): VmTemplate;
+            lower(value: VmTemplate, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeVmTemplateBuilder: FfiConverterObject<VmTemplateBuilderLike>;
+        FfiConverterTypeWarmPoolAutoscaling: {
+            read(from: RustBuffer): WarmPoolAutoscaling;
+            write(value: WarmPoolAutoscaling, into: RustBuffer): void;
+            allocationSize(value: WarmPoolAutoscaling): number;
+            lift(value: UniffiByteArray): WarmPoolAutoscaling;
+            lower(value: WarmPoolAutoscaling, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeWarmPoolAutoscalingBuilder: FfiConverterObject<WarmPoolAutoscalingBuilderLike>;
+        FfiConverterTypeWarmPoolTtlPolicy: {
+            read(from: RustBuffer): WarmPoolTtlPolicy;
+            write(value: WarmPoolTtlPolicy, into: RustBuffer): void;
+            allocationSize(value: WarmPoolTtlPolicy): number;
+            lift(value: UniffiByteArray): WarmPoolTtlPolicy;
+            lower(value: WarmPoolTtlPolicy, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;