@trycua/cua 0.2.0

package/browser/cyclops_sdk_schema.js

@@ -0,0 +1,2194 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import * as wasmBundle from "./wasm-bindgen/index.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterInt32, FfiConverterMap, FfiConverterObject, FfiConverterOptional, FfiConverterUInt16, FfiConverterUInt32, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol, } from "@ubjs/core";
+// wasm1: wrap the wasm-bindgen namespace once so the codegen call sites can
+// uniformly reference `nativeModule().rustbuffer_alloc` / `.rustbuffer_free`.
+// For wasm1, RustBuffers are plain JS Uint8Arrays — no Rust-side allocation
+// is involved, so alloc just hands back a fresh view and free is a no-op.
+const _nativeModule = Object.assign({}, wasmBundle, {
+    rustbuffer_alloc: (n) => new Uint8Array(n),
+    rustbuffer_free: (_) => { },
+});
+const nativeModule = () => _nativeModule;
+const uniffiCaller = new UniffiRustCaller(() => new wasmBundle.RustCallStatus());
+const uniffiIsDebug = 
+// @ts-ignore -- The process global might not be defined
+typeof process !== "object" ||
+    // @ts-ignore -- The process global might not be defined
+    process?.env?.NODE_ENV !== "production" ||
+    false;
+// Public interface members begin here.
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s) => encoder.encode(s),
+        bytesToString: (ab) => decoder.decode(ab),
+        stringByteLength: (s) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s, buf, offset) => {
+            const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+/**
+ * Generated factory for {@link ClaimLifecycle} record objects.
+ */
+export const ClaimLifecycle = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClaimLifecycle = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                shutdownTime: FfiConverterOptionalString.read(from),
+                shutdownPolicy: FfiConverterOptionalString.read(from),
+                autoRenew: FfiConverterOptionalBoolean.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.shutdownTime, into);
+            FfiConverterOptionalString.write(value.shutdownPolicy, into);
+            FfiConverterOptionalBoolean.write(value.autoRenew, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.shutdownTime) +
+                FfiConverterOptionalString.allocationSize(value.shutdownPolicy) +
+                FfiConverterOptionalBoolean.allocationSize(value.autoRenew);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ClaimSecretRef} record objects.
+ */
+export const ClaimSecretRef = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClaimSecretRef = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link SandboxTemplateRef} record objects.
+ */
+export const SandboxTemplateRef = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSandboxTemplateRef = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ClaimSpec} record objects.
+ */
+export const ClaimSpec = (() => {
+    const defaults = () => ({
+        ttlSecondsAfterCreated: undefined,
+        secretRef: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeClaimSpec = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                sandboxTemplateRef: FfiConverterTypeSandboxTemplateRef.read(from),
+                warmpool: FfiConverterOptionalString.read(from),
+                bindDeadline: FfiConverterOptionalUInt32.read(from),
+                lifecycle: FfiConverterOptionalTypeClaimLifecycle.read(from),
+                ttlSecondsAfterCreated: FfiConverterOptionalUInt32.read(from),
+                secretRef: FfiConverterOptionalTypeClaimSecretRef.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeSandboxTemplateRef.write(value.sandboxTemplateRef, into);
+            FfiConverterOptionalString.write(value.warmpool, into);
+            FfiConverterOptionalUInt32.write(value.bindDeadline, into);
+            FfiConverterOptionalTypeClaimLifecycle.write(value.lifecycle, into);
+            FfiConverterOptionalUInt32.write(value.ttlSecondsAfterCreated, into);
+            FfiConverterOptionalTypeClaimSecretRef.write(value.secretRef, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeSandboxTemplateRef.allocationSize(value.sandboxTemplateRef) +
+                FfiConverterOptionalString.allocationSize(value.warmpool) +
+                FfiConverterOptionalUInt32.allocationSize(value.bindDeadline) +
+                FfiConverterOptionalTypeClaimLifecycle.allocationSize(value.lifecycle) +
+                FfiConverterOptionalUInt32.allocationSize(value.ttlSecondsAfterCreated) +
+                FfiConverterOptionalTypeClaimSecretRef.allocationSize(value.secretRef);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxClaimCondition} record objects.
+ */
+export const OsGymSandboxClaimCondition = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxClaimCondition = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                type: FfiConverterOptionalString.read(from),
+                status: FfiConverterOptionalString.read(from),
+                reason: FfiConverterOptionalString.read(from),
+                message: FfiConverterOptionalString.read(from),
+                lastTransitionTime: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.type, into);
+            FfiConverterOptionalString.write(value.status, into);
+            FfiConverterOptionalString.write(value.reason, into);
+            FfiConverterOptionalString.write(value.message, into);
+            FfiConverterOptionalString.write(value.lastTransitionTime, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.type) +
+                FfiConverterOptionalString.allocationSize(value.status) +
+                FfiConverterOptionalString.allocationSize(value.reason) +
+                FfiConverterOptionalString.allocationSize(value.message) +
+                FfiConverterOptionalString.allocationSize(value.lastTransitionTime);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxClaimSandbox} record objects.
+ */
+export const OsGymSandboxClaimSandbox = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxClaimSandbox = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterOptionalString.read(from),
+                service: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.name, into);
+            FfiConverterOptionalString.write(value.service, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.name) +
+                FfiConverterOptionalString.allocationSize(value.service);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxClaimStatus} record objects.
+ */
+export const OsGymSandboxClaimStatus = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxClaimStatus = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                phase: FfiConverterOptionalString.read(from),
+                conditions: FfiConverterOptionalSequenceTypeOSGymSandboxClaimCondition.read(from),
+                sandbox: FfiConverterOptionalTypeOSGymSandboxClaimSandbox.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.phase, into);
+            FfiConverterOptionalSequenceTypeOSGymSandboxClaimCondition.write(value.conditions, into);
+            FfiConverterOptionalTypeOSGymSandboxClaimSandbox.write(value.sandbox, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.phase) +
+                FfiConverterOptionalSequenceTypeOSGymSandboxClaimCondition.allocationSize(value.conditions) +
+                FfiConverterOptionalTypeOSGymSandboxClaimSandbox.allocationSize(value.sandbox);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+export var RuntimeKind;
+(function (RuntimeKind) {
+    RuntimeKind[RuntimeKind["Kubevirt"] = 0] = "Kubevirt";
+    RuntimeKind[RuntimeKind["Macos"] = 1] = "Macos";
+    RuntimeKind[RuntimeKind["Gvisor"] = 2] = "Gvisor";
+})(RuntimeKind || (RuntimeKind = {}));
+const FfiConverterTypeRuntimeKind = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return RuntimeKind.Kubevirt;
+                case 2: return RuntimeKind.Macos;
+                case 3: return RuntimeKind.Gvisor;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case RuntimeKind.Kubevirt: return ordinalConverter.write(1, into);
+                case RuntimeKind.Macos: return ordinalConverter.write(2, into);
+                case RuntimeKind.Gvisor: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export class PreservedJson extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "PreservedJson";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypePreservedJsonObjectFactory.bless(pointer);
+    }
+    static fromJson(value) {
+        return FfiConverterTypePreservedJson.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeJsonValueError.lift.bind(FfiConverterTypeJsonValueError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_preservedjson_from_json(FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    toJson() {
+        return ((__rb) => {
+            try {
+                return FfiConverterString.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_preservedjson_to_json(uniffiTypePreservedJsonObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypePreservedJsonObjectFactory.pointer(this);
+            uniffiTypePreservedJsonObjectFactory.freePointer(pointer);
+            uniffiTypePreservedJsonObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypePreservedJsonObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypePreservedJsonObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypePreservedJsonObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(PreservedJson.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "PreservedJson";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_preservedjson(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_preservedjson(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "PreservedJson";
+        },
+    };
+})();
+const FfiConverterTypePreservedJson = new FfiConverterObject(uniffiTypePreservedJsonObjectFactory);
+export var ImagePullPolicy;
+(function (ImagePullPolicy) {
+    ImagePullPolicy[ImagePullPolicy["Always"] = 0] = "Always";
+    ImagePullPolicy[ImagePullPolicy["IfNotPresent"] = 1] = "IfNotPresent";
+    ImagePullPolicy[ImagePullPolicy["Never"] = 2] = "Never";
+})(ImagePullPolicy || (ImagePullPolicy = {}));
+const FfiConverterTypeImagePullPolicy = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ImagePullPolicy.Always;
+                case 2: return ImagePullPolicy.IfNotPresent;
+                case 3: return ImagePullPolicy.Never;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ImagePullPolicy.Always: return ordinalConverter.write(1, into);
+                case ImagePullPolicy.IfNotPresent: return ordinalConverter.write(2, into);
+                case ImagePullPolicy.Never: return ordinalConverter.write(3, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var Firmware;
+(function (Firmware) {
+    Firmware[Firmware["Bios"] = 0] = "Bios";
+    Firmware[Firmware["Efi"] = 1] = "Efi";
+})(Firmware || (Firmware = {}));
+const FfiConverterTypeFirmware = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return Firmware.Bios;
+                case 2: return Firmware.Efi;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case Firmware.Bios: return ordinalConverter.write(1, into);
+                case Firmware.Efi: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+export var ServiceProtocol;
+(function (ServiceProtocol) {
+    ServiceProtocol[ServiceProtocol["Tcp"] = 0] = "Tcp";
+    ServiceProtocol[ServiceProtocol["Udp"] = 1] = "Udp";
+})(ServiceProtocol || (ServiceProtocol = {}));
+const FfiConverterTypeServiceProtocol = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ServiceProtocol.Tcp;
+                case 2: return ServiceProtocol.Udp;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ServiceProtocol.Tcp: return ordinalConverter.write(1, into);
+                case ServiceProtocol.Udp: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link SandboxService} record objects.
+ */
+export const SandboxService = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeSandboxService = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterString.read(from),
+                targetPort: FfiConverterUInt16.read(from),
+                protocol: FfiConverterOptionalTypeServiceProtocol.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.name, into);
+            FfiConverterUInt16.write(value.targetPort, into);
+            FfiConverterOptionalTypeServiceProtocol.write(value.protocol, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.name) +
+                FfiConverterUInt16.allocationSize(value.targetPort) +
+                FfiConverterOptionalTypeServiceProtocol.allocationSize(value.protocol);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OidcConfig} record objects.
+ */
+export const OidcConfig = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOidcConfig = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                credentialsSecret: FfiConverterString.read(from),
+                tokenUrl: FfiConverterString.read(from),
+                awsRoleArn: FfiConverterOptionalString.read(from),
+                awsRegion: FfiConverterOptionalString.read(from),
+                refreshIntervalSeconds: FfiConverterOptionalUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.credentialsSecret, into);
+            FfiConverterString.write(value.tokenUrl, into);
+            FfiConverterOptionalString.write(value.awsRoleArn, into);
+            FfiConverterOptionalString.write(value.awsRegion, into);
+            FfiConverterOptionalUInt32.write(value.refreshIntervalSeconds, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.credentialsSecret) +
+                FfiConverterString.allocationSize(value.tokenUrl) +
+                FfiConverterOptionalString.allocationSize(value.awsRoleArn) +
+                FfiConverterOptionalString.allocationSize(value.awsRegion) +
+                FfiConverterOptionalUInt32.allocationSize(value.refreshIntervalSeconds);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * How `vmTemplate.command`/`args`/`env` reach the sandbox
+ * (`vmTemplate.processMode`). Absent means `Legacy`.
+ */
+export var ProcessMode;
+(function (ProcessMode) {
+    /**
+     * What templates did before processMode existed: pod runtimes run
+     * command/args/env; KubeVirt ignores command and refuses args/env.
+     */
+    ProcessMode[ProcessMode["Legacy"] = 0] = "Legacy";
+    /**
+     * Every runtime runs command/args/env. Pod runtimes set them on the
+     * sandbox container; KubeVirt renders them into the sandbox's cloud-init.
+     */
+    ProcessMode[ProcessMode["Run"] = 1] = "Run";
+})(ProcessMode || (ProcessMode = {}));
+const FfiConverterTypeProcessMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ProcessMode.Legacy;
+                case 2: return ProcessMode.Run;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ProcessMode.Legacy: return ordinalConverter.write(1, into);
+                case ProcessMode.Run: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link VmTemplate} record objects.
+ */
+export const VmTemplate = (() => {
+    const defaults = () => ({
+        claimSecrets: undefined,
+        args: undefined,
+        env: undefined,
+        processMode: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeVmTemplate = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                containerDiskImage: FfiConverterString.read(from),
+                command: FfiConverterOptionalSequenceString.read(from),
+                runtime: FfiConverterOptionalTypeRuntimeKind.read(from),
+                runtimeClassName: FfiConverterOptionalString.read(from),
+                nodeSelector: FfiConverterOptionalMapStringString.read(from),
+                tolerations: FfiConverterOptionalSequenceTypePreservedJson.read(from),
+                imagePullPolicy: FfiConverterOptionalTypeImagePullPolicy.read(from),
+                imagePullSecret: FfiConverterOptionalString.read(from),
+                cpuCores: FfiConverterOptionalUInt32.read(from),
+                memory: FfiConverterOptionalString.read(from),
+                firmware: FfiConverterOptionalTypeFirmware.read(from),
+                nestedVirtualization: FfiConverterOptionalBoolean.read(from),
+                probes: FfiConverterOptionalTypePreservedJson.read(from),
+                services: FfiConverterOptionalSequenceTypeSandboxService.read(from),
+                oidc: FfiConverterOptionalTypeOidcConfig.read(from),
+                claimSecrets: FfiConverterOptionalBoolean.read(from),
+                args: FfiConverterOptionalSequenceString.read(from),
+                env: FfiConverterOptionalMapStringString.read(from),
+                processMode: FfiConverterOptionalTypeProcessMode.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.containerDiskImage, into);
+            FfiConverterOptionalSequenceString.write(value.command, into);
+            FfiConverterOptionalTypeRuntimeKind.write(value.runtime, into);
+            FfiConverterOptionalString.write(value.runtimeClassName, into);
+            FfiConverterOptionalMapStringString.write(value.nodeSelector, into);
+            FfiConverterOptionalSequenceTypePreservedJson.write(value.tolerations, into);
+            FfiConverterOptionalTypeImagePullPolicy.write(value.imagePullPolicy, into);
+            FfiConverterOptionalString.write(value.imagePullSecret, into);
+            FfiConverterOptionalUInt32.write(value.cpuCores, into);
+            FfiConverterOptionalString.write(value.memory, into);
+            FfiConverterOptionalTypeFirmware.write(value.firmware, into);
+            FfiConverterOptionalBoolean.write(value.nestedVirtualization, into);
+            FfiConverterOptionalTypePreservedJson.write(value.probes, into);
+            FfiConverterOptionalSequenceTypeSandboxService.write(value.services, into);
+            FfiConverterOptionalTypeOidcConfig.write(value.oidc, into);
+            FfiConverterOptionalBoolean.write(value.claimSecrets, into);
+            FfiConverterOptionalSequenceString.write(value.args, into);
+            FfiConverterOptionalMapStringString.write(value.env, into);
+            FfiConverterOptionalTypeProcessMode.write(value.processMode, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.containerDiskImage) +
+                FfiConverterOptionalSequenceString.allocationSize(value.command) +
+                FfiConverterOptionalTypeRuntimeKind.allocationSize(value.runtime) +
+                FfiConverterOptionalString.allocationSize(value.runtimeClassName) +
+                FfiConverterOptionalMapStringString.allocationSize(value.nodeSelector) +
+                FfiConverterOptionalSequenceTypePreservedJson.allocationSize(value.tolerations) +
+                FfiConverterOptionalTypeImagePullPolicy.allocationSize(value.imagePullPolicy) +
+                FfiConverterOptionalString.allocationSize(value.imagePullSecret) +
+                FfiConverterOptionalUInt32.allocationSize(value.cpuCores) +
+                FfiConverterOptionalString.allocationSize(value.memory) +
+                FfiConverterOptionalTypeFirmware.allocationSize(value.firmware) +
+                FfiConverterOptionalBoolean.allocationSize(value.nestedVirtualization) +
+                FfiConverterOptionalTypePreservedJson.allocationSize(value.probes) +
+                FfiConverterOptionalSequenceTypeSandboxService.allocationSize(value.services) +
+                FfiConverterOptionalTypeOidcConfig.allocationSize(value.oidc) +
+                FfiConverterOptionalBoolean.allocationSize(value.claimSecrets) +
+                FfiConverterOptionalSequenceString.allocationSize(value.args) +
+                FfiConverterOptionalMapStringString.allocationSize(value.env) +
+                FfiConverterOptionalTypeProcessMode.allocationSize(value.processMode);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxSpec} record objects.
+ */
+export const OsGymSandboxSpec = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxSpec = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                vmTemplate: FfiConverterTypeVmTemplate.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeVmTemplate.write(value.vmTemplate, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeVmTemplate.allocationSize(value.vmTemplate);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxStatus} record objects.
+ */
+export const OsGymSandboxStatus = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxStatus = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                phase: FfiConverterOptionalString.read(from),
+                runtime: FfiConverterOptionalString.read(from),
+                ready: FfiConverterOptionalBoolean.read(from),
+                vmName: FfiConverterOptionalString.read(from),
+                service: FfiConverterOptionalString.read(from),
+                message: FfiConverterOptionalString.read(from),
+                resetIssuedAt: FfiConverterOptionalString.read(from),
+                resetVmiUid: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalString.write(value.phase, into);
+            FfiConverterOptionalString.write(value.runtime, into);
+            FfiConverterOptionalBoolean.write(value.ready, into);
+            FfiConverterOptionalString.write(value.vmName, into);
+            FfiConverterOptionalString.write(value.service, into);
+            FfiConverterOptionalString.write(value.message, into);
+            FfiConverterOptionalString.write(value.resetIssuedAt, into);
+            FfiConverterOptionalString.write(value.resetVmiUid, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalString.allocationSize(value.phase) +
+                FfiConverterOptionalString.allocationSize(value.runtime) +
+                FfiConverterOptionalBoolean.allocationSize(value.ready) +
+                FfiConverterOptionalString.allocationSize(value.vmName) +
+                FfiConverterOptionalString.allocationSize(value.service) +
+                FfiConverterOptionalString.allocationSize(value.message) +
+                FfiConverterOptionalString.allocationSize(value.resetIssuedAt) +
+                FfiConverterOptionalString.allocationSize(value.resetVmiUid);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxTemplateSpec} record objects.
+ */
+export const OsGymSandboxTemplateSpec = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxTemplateSpec = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                vmTemplate: FfiConverterTypeVmTemplate.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeVmTemplate.write(value.vmTemplate, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeVmTemplate.allocationSize(value.vmTemplate);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link WarmPoolAutoscaling} record objects.
+ */
+export const WarmPoolAutoscaling = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeWarmPoolAutoscaling = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                minPoolSize: FfiConverterOptionalUInt32.read(from),
+                initialPoolSize: FfiConverterOptionalUInt32.read(from),
+                maxPoolSize: FfiConverterOptionalUInt32.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalUInt32.write(value.minPoolSize, into);
+            FfiConverterOptionalUInt32.write(value.initialPoolSize, into);
+            FfiConverterOptionalUInt32.write(value.maxPoolSize, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalUInt32.allocationSize(value.minPoolSize) +
+                FfiConverterOptionalUInt32.allocationSize(value.initialPoolSize) +
+                FfiConverterOptionalUInt32.allocationSize(value.maxPoolSize);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * What the pool-operator deletes when a warm pool's creation TTL
+ * (`ttlSecondsAfterCreated`) or idle TTL (`idleTtlSeconds`) expires.
+ */
+export var WarmPoolTtlPolicy;
+(function (WarmPoolTtlPolicy) {
+    /**
+     * Delete only the warm pool. Its claims and namespace stay.
+     */
+    WarmPoolTtlPolicy[WarmPoolTtlPolicy["Retain"] = 0] = "Retain";
+    /**
+     * Also delete the pool's dead unbound claims (TTL passed, older than
+     * max(900s, bindDeadline)). Bound claims, the namespace and volumes stay.
+     */
+    WarmPoolTtlPolicy[WarmPoolTtlPolicy["Cascade"] = 1] = "Cascade";
+})(WarmPoolTtlPolicy || (WarmPoolTtlPolicy = {}));
+const FfiConverterTypeWarmPoolTtlPolicy = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return WarmPoolTtlPolicy.Retain;
+                case 2: return WarmPoolTtlPolicy.Cascade;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case WarmPoolTtlPolicy.Retain: return ordinalConverter.write(1, into);
+                case WarmPoolTtlPolicy.Cascade: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxWarmPoolSpec} record objects.
+ */
+export const OsGymSandboxWarmPoolSpec = (() => {
+    const defaults = () => ({
+        ttlSecondsAfterCreated: undefined,
+        idleTtlSeconds: undefined,
+        ttlPolicy: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxWarmPoolSpec = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                replicas: FfiConverterUInt32.read(from),
+                sandboxTemplateRef: FfiConverterTypeSandboxTemplateRef.read(from),
+                autoscaling: FfiConverterOptionalTypeWarmPoolAutoscaling.read(from),
+                ttlSecondsAfterCreated: FfiConverterOptionalUInt32.read(from),
+                idleTtlSeconds: FfiConverterOptionalUInt32.read(from),
+                ttlPolicy: FfiConverterOptionalTypeWarmPoolTtlPolicy.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterUInt32.write(value.replicas, into);
+            FfiConverterTypeSandboxTemplateRef.write(value.sandboxTemplateRef, into);
+            FfiConverterOptionalTypeWarmPoolAutoscaling.write(value.autoscaling, into);
+            FfiConverterOptionalUInt32.write(value.ttlSecondsAfterCreated, into);
+            FfiConverterOptionalUInt32.write(value.idleTtlSeconds, into);
+            FfiConverterOptionalTypeWarmPoolTtlPolicy.write(value.ttlPolicy, into);
+        }
+        allocationSize(value) {
+            return FfiConverterUInt32.allocationSize(value.replicas) +
+                FfiConverterTypeSandboxTemplateRef.allocationSize(value.sandboxTemplateRef) +
+                FfiConverterOptionalTypeWarmPoolAutoscaling.allocationSize(value.autoscaling) +
+                FfiConverterOptionalUInt32.allocationSize(value.ttlSecondsAfterCreated) +
+                FfiConverterOptionalUInt32.allocationSize(value.idleTtlSeconds) +
+                FfiConverterOptionalTypeWarmPoolTtlPolicy.allocationSize(value.ttlPolicy);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link OsGymSandboxWarmPoolStatus} record objects.
+ */
+export const OsGymSandboxWarmPoolStatus = (() => {
+    const defaults = () => ({
+        lastClaimedAt: undefined,
+        lastActivityTime: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOSGymSandboxWarmPoolStatus = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                replicas: FfiConverterOptionalUInt32.read(from),
+                readyReplicas: FfiConverterOptionalUInt32.read(from),
+                selector: FfiConverterOptionalString.read(from),
+                lastClaimedAt: FfiConverterOptionalString.read(from),
+                lastActivityTime: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterOptionalUInt32.write(value.replicas, into);
+            FfiConverterOptionalUInt32.write(value.readyReplicas, into);
+            FfiConverterOptionalString.write(value.selector, into);
+            FfiConverterOptionalString.write(value.lastClaimedAt, into);
+            FfiConverterOptionalString.write(value.lastActivityTime, into);
+        }
+        allocationSize(value) {
+            return FfiConverterOptionalUInt32.allocationSize(value.replicas) +
+                FfiConverterOptionalUInt32.allocationSize(value.readyReplicas) +
+                FfiConverterOptionalString.allocationSize(value.selector) +
+                FfiConverterOptionalString.allocationSize(value.lastClaimedAt) +
+                FfiConverterOptionalString.allocationSize(value.lastActivityTime);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+// Error type: JsonValueError
+export var JsonValueError_Tags;
+(function (JsonValueError_Tags) {
+    JsonValueError_Tags["Invalid"] = "Invalid";
+})(JsonValueError_Tags || (JsonValueError_Tags = {}));
+export const JsonValueError = (() => {
+    class Invalid_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "JsonValueError";
+        tag = JsonValueError_Tags.Invalid;
+        inner;
+        constructor(inner) {
+            super("JsonValueError", "Invalid");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Invalid_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === JsonValueError_Tags.Invalid;
+        }
+        static hasInner(obj) {
+            return Invalid_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "JsonValueError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Invalid: Invalid_
+    });
+})();
+// FfiConverter for enum JsonValueError
+const FfiConverterTypeJsonValueError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new JsonValueError.Invalid({ reason: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case JsonValueError_Tags.Invalid: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.reason, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that JsonValueError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case JsonValueError_Tags.Invalid: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.reason);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: SchemaBuildError
+export var SchemaBuildError_Tags;
+(function (SchemaBuildError_Tags) {
+    SchemaBuildError_Tags["MissingRequiredField"] = "MissingRequiredField";
+})(SchemaBuildError_Tags || (SchemaBuildError_Tags = {}));
+export const SchemaBuildError = (() => {
+    class MissingRequiredField_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "SchemaBuildError";
+        tag = SchemaBuildError_Tags.MissingRequiredField;
+        inner;
+        constructor(inner) {
+            super("SchemaBuildError", "MissingRequiredField");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new MissingRequiredField_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === SchemaBuildError_Tags.MissingRequiredField;
+        }
+        static hasInner(obj) {
+            return MissingRequiredField_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "SchemaBuildError";
+    }
+    return Object.freeze({
+        instanceOf,
+        MissingRequiredField: MissingRequiredField_
+    });
+})();
+// FfiConverter for enum SchemaBuildError
+const FfiConverterTypeSchemaBuildError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return new SchemaBuildError.MissingRequiredField({ recordType: FfiConverterString.read(from), field: FfiConverterString.read(from) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case SchemaBuildError_Tags.MissingRequiredField: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.recordType, into);
+                    FfiConverterString.write(inner.field, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that SchemaBuildError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case SchemaBuildError_Tags.MissingRequiredField: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.recordType);
+                    size += FfiConverterString.allocationSize(inner.field);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+export class OsGymSandboxTemplateSpecBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "OsGymSandboxTemplateSpecBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_osgymsandboxtemplatespecbuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.bless(pointer);
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeOSGymSandboxTemplateSpec.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxtemplatespecbuilder_build(uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    vmTemplate(value) {
+        return FfiConverterTypeOSGymSandboxTemplateSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxtemplatespecbuilder_vm_template(uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.clonePointer(this), FfiConverterTypeVmTemplate.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.pointer(this);
+            uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(OsGymSandboxTemplateSpecBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "OsGymSandboxTemplateSpecBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_osgymsandboxtemplatespecbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_osgymsandboxtemplatespecbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "OsGymSandboxTemplateSpecBuilder";
+        },
+    };
+})();
+const FfiConverterTypeOSGymSandboxTemplateSpecBuilder = new FfiConverterObject(uniffiTypeOsGymSandboxTemplateSpecBuilderObjectFactory);
+export class OsGymSandboxWarmPoolSpecBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "OsGymSandboxWarmPoolSpecBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_osgymsandboxwarmpoolspecbuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.bless(pointer);
+    }
+    autoscaling(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_autoscaling(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterTypeWarmPoolAutoscaling.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeOSGymSandboxWarmPoolSpec.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_build(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    idleTtlSeconds(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_idle_ttl_seconds(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    replicas(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_replicas(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    sandboxTemplateRef(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_sandbox_template_ref(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterTypeSandboxTemplateRef.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    ttlPolicy(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_ttl_policy(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterTypeWarmPoolTtlPolicy.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    ttlSecondsAfterCreated(value) {
+        return FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_osgymsandboxwarmpoolspecbuilder_ttl_seconds_after_created(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.pointer(this);
+            uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(OsGymSandboxWarmPoolSpecBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "OsGymSandboxWarmPoolSpecBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_osgymsandboxwarmpoolspecbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_osgymsandboxwarmpoolspecbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "OsGymSandboxWarmPoolSpecBuilder";
+        },
+    };
+})();
+const FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder = new FfiConverterObject(uniffiTypeOsGymSandboxWarmPoolSpecBuilderObjectFactory);
+export class SandboxServiceBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "SandboxServiceBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_sandboxservicebuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeSandboxServiceBuilderObjectFactory.bless(pointer);
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeSandboxService.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxservicebuilder_build(uniffiTypeSandboxServiceBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    name(value) {
+        return FfiConverterTypeSandboxServiceBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxservicebuilder_name(uniffiTypeSandboxServiceBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    protocol(value) {
+        return FfiConverterTypeSandboxServiceBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxservicebuilder_protocol(uniffiTypeSandboxServiceBuilderObjectFactory.clonePointer(this), FfiConverterTypeServiceProtocol.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    targetPort(value) {
+        return FfiConverterTypeSandboxServiceBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxservicebuilder_target_port(uniffiTypeSandboxServiceBuilderObjectFactory.clonePointer(this), FfiConverterUInt16.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSandboxServiceBuilderObjectFactory.pointer(this);
+            uniffiTypeSandboxServiceBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeSandboxServiceBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeSandboxServiceBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeSandboxServiceBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeSandboxServiceBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(SandboxServiceBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "SandboxServiceBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_sandboxservicebuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_sandboxservicebuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "SandboxServiceBuilder";
+        },
+    };
+})();
+const FfiConverterTypeSandboxServiceBuilder = new FfiConverterObject(uniffiTypeSandboxServiceBuilderObjectFactory);
+export class SandboxTemplateRefBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "SandboxTemplateRefBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_sandboxtemplaterefbuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeSandboxTemplateRefBuilderObjectFactory.bless(pointer);
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeSandboxTemplateRef.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxtemplaterefbuilder_build(uniffiTypeSandboxTemplateRefBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    name(value) {
+        return FfiConverterTypeSandboxTemplateRefBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_sandboxtemplaterefbuilder_name(uniffiTypeSandboxTemplateRefBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeSandboxTemplateRefBuilderObjectFactory.pointer(this);
+            uniffiTypeSandboxTemplateRefBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeSandboxTemplateRefBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeSandboxTemplateRefBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeSandboxTemplateRefBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeSandboxTemplateRefBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(SandboxTemplateRefBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "SandboxTemplateRefBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_sandboxtemplaterefbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_sandboxtemplaterefbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "SandboxTemplateRefBuilder";
+        },
+    };
+})();
+const FfiConverterTypeSandboxTemplateRefBuilder = new FfiConverterObject(uniffiTypeSandboxTemplateRefBuilderObjectFactory);
+export class VmTemplateBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "VmTemplateBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_vmtemplatebuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeVmTemplateBuilderObjectFactory.bless(pointer);
+    }
+    args(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_args(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterSequenceString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeVmTemplate.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_build(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    claimSecrets(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_claim_secrets(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterBool.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    command(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_command(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterSequenceString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    containerDiskImage(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_container_disk_image(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    cpuCores(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_cpu_cores(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    env(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_env(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterMapStringString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    firmware(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_firmware(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypeFirmware.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    imagePullPolicy(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_image_pull_policy(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypeImagePullPolicy.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    imagePullSecret(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_image_pull_secret(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    memory(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_memory(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    nestedVirtualization(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_nested_virtualization(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterBool.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    nodeSelector(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_node_selector(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterMapStringString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    oidc(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_oidc(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypeOidcConfig.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    probes(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_probes(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypePreservedJson.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    processMode(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_process_mode(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypeProcessMode.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    runtime(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_runtime(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterTypeRuntimeKind.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    runtimeClassName(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_runtime_class_name(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterString.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    services(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_services(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterSequenceTypeSandboxService.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    tolerations(value) {
+        return FfiConverterTypeVmTemplateBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_vmtemplatebuilder_tolerations(uniffiTypeVmTemplateBuilderObjectFactory.clonePointer(this), FfiConverterSequenceTypePreservedJson.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeVmTemplateBuilderObjectFactory.pointer(this);
+            uniffiTypeVmTemplateBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeVmTemplateBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeVmTemplateBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeVmTemplateBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeVmTemplateBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(VmTemplateBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "VmTemplateBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_vmtemplatebuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_vmtemplatebuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "VmTemplateBuilder";
+        },
+    };
+})();
+const FfiConverterTypeVmTemplateBuilder = new FfiConverterObject(uniffiTypeVmTemplateBuilderObjectFactory);
+export class WarmPoolAutoscalingBuilder extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "WarmPoolAutoscalingBuilder";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor() {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_constructor_warmpoolautoscalingbuilder_new(callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] = uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.bless(pointer);
+    }
+    build() {
+        return ((__rb) => {
+            try {
+                return FfiConverterTypeWarmPoolAutoscaling.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSchemaBuildError.lift.bind(FfiConverterTypeSchemaBuildError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_warmpoolautoscalingbuilder_build(uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    initialPoolSize(value) {
+        return FfiConverterTypeWarmPoolAutoscalingBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_warmpoolautoscalingbuilder_initial_pool_size(uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    maxPoolSize(value) {
+        return FfiConverterTypeWarmPoolAutoscalingBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_warmpoolautoscalingbuilder_max_pool_size(uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    minPoolSize(value) {
+        return FfiConverterTypeWarmPoolAutoscalingBuilder.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_method_warmpoolautoscalingbuilder_min_pool_size(uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.clonePointer(this), FfiConverterUInt32.lower(value, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.pointer(this);
+            uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.freePointer(pointer);
+            uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj_) {
+        return uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.isConcreteType(obj_);
+    }
+}
+const uniffiTypeWarmPoolAutoscalingBuilderObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry((heldValue) => {
+        uniffiTypeWarmPoolAutoscalingBuilderObjectFactory.freePointer(heldValue);
+    }) : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(WarmPoolAutoscalingBuilder.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "WarmPoolAutoscalingBuilder";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr_) {
+            if (registry) {
+                registry.unregister(ptr_);
+            }
+        },
+        pointer(obj_) {
+            if (obj_[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj_[pointerLiteralSymbol];
+        },
+        clonePointer(obj_) {
+            const pointer = this.pointer(obj_);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_clone_warmpoolautoscalingbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_cyclops_sdk_schema_fn_free_warmpoolautoscalingbuilder(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj_) {
+            return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "WarmPoolAutoscalingBuilder";
+        },
+    };
+})();
+const FfiConverterTypeWarmPoolAutoscalingBuilder = new FfiConverterObject(uniffiTypeWarmPoolAutoscalingBuilderObjectFactory);
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+// FfiConverter for ClaimLifecycle | undefined
+const FfiConverterOptionalTypeClaimLifecycle = new FfiConverterOptional(FfiConverterTypeClaimLifecycle);
+// FfiConverter for ClaimSecretRef | undefined
+const FfiConverterOptionalTypeClaimSecretRef = new FfiConverterOptional(FfiConverterTypeClaimSecretRef);
+// FfiConverter for Array<OsGymSandboxClaimCondition>
+const FfiConverterSequenceTypeOSGymSandboxClaimCondition = new FfiConverterArray(FfiConverterTypeOSGymSandboxClaimCondition);
+// FfiConverter for Array<OsGymSandboxClaimCondition> | undefined
+const FfiConverterOptionalSequenceTypeOSGymSandboxClaimCondition = new FfiConverterOptional(FfiConverterSequenceTypeOSGymSandboxClaimCondition);
+// FfiConverter for OsGymSandboxClaimSandbox | undefined
+const FfiConverterOptionalTypeOSGymSandboxClaimSandbox = new FfiConverterOptional(FfiConverterTypeOSGymSandboxClaimSandbox);
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+// FfiConverter for Array<string> | undefined
+const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+// FfiConverter for RuntimeKind | undefined
+const FfiConverterOptionalTypeRuntimeKind = new FfiConverterOptional(FfiConverterTypeRuntimeKind);
+// FfiConverter for Map<string, string>
+const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+// FfiConverter for Map<string, string> | undefined
+const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
+// FfiConverter for Array<PreservedJsonLike>
+const FfiConverterSequenceTypePreservedJson = new FfiConverterArray(FfiConverterTypePreservedJson);
+// FfiConverter for Array<PreservedJsonLike> | undefined
+const FfiConverterOptionalSequenceTypePreservedJson = new FfiConverterOptional(FfiConverterSequenceTypePreservedJson);
+// FfiConverter for ImagePullPolicy | undefined
+const FfiConverterOptionalTypeImagePullPolicy = new FfiConverterOptional(FfiConverterTypeImagePullPolicy);
+// FfiConverter for Firmware | undefined
+const FfiConverterOptionalTypeFirmware = new FfiConverterOptional(FfiConverterTypeFirmware);
+// FfiConverter for PreservedJsonLike | undefined
+const FfiConverterOptionalTypePreservedJson = new FfiConverterOptional(FfiConverterTypePreservedJson);
+// FfiConverter for ServiceProtocol | undefined
+const FfiConverterOptionalTypeServiceProtocol = new FfiConverterOptional(FfiConverterTypeServiceProtocol);
+// FfiConverter for Array<SandboxService>
+const FfiConverterSequenceTypeSandboxService = new FfiConverterArray(FfiConverterTypeSandboxService);
+// FfiConverter for Array<SandboxService> | undefined
+const FfiConverterOptionalSequenceTypeSandboxService = new FfiConverterOptional(FfiConverterSequenceTypeSandboxService);
+// FfiConverter for OidcConfig | undefined
+const FfiConverterOptionalTypeOidcConfig = new FfiConverterOptional(FfiConverterTypeOidcConfig);
+// FfiConverter for ProcessMode | undefined
+const FfiConverterOptionalTypeProcessMode = new FfiConverterOptional(FfiConverterTypeProcessMode);
+// FfiConverter for WarmPoolAutoscaling | undefined
+const FfiConverterOptionalTypeWarmPoolAutoscaling = new FfiConverterOptional(FfiConverterTypeWarmPoolAutoscaling);
+// FfiConverter for WarmPoolTtlPolicy | undefined
+const FfiConverterOptionalTypeWarmPoolTtlPolicy = new FfiConverterOptional(FfiConverterTypeWarmPoolTtlPolicy);
+/**
+ * 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.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_cyclops_sdk_schema_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_osgymsandboxtemplatespecbuilder_new() !== 22071) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_osgymsandboxtemplatespecbuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxtemplatespecbuilder_build() !== 53928) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxtemplatespecbuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxtemplatespecbuilder_vm_template() !== 6610) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxtemplatespecbuilder_vm_template");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_osgymsandboxwarmpoolspecbuilder_new() !== 26063) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_osgymsandboxwarmpoolspecbuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_autoscaling() !== 44912) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_autoscaling");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_build() !== 5682) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_idle_ttl_seconds() !== 56677) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_idle_ttl_seconds");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_replicas() !== 50438) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_replicas");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_sandbox_template_ref() !== 7198) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_sandbox_template_ref");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_ttl_policy() !== 53364) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_ttl_policy");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_ttl_seconds_after_created() !== 44516) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_osgymsandboxwarmpoolspecbuilder_ttl_seconds_after_created");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_preservedjson_from_json() !== 24064) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_preservedjson_from_json");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_preservedjson_to_json() !== 8252) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_preservedjson_to_json");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_sandboxservicebuilder_new() !== 21082) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_sandboxservicebuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_build() !== 62919) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_name() !== 62417) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_name");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_protocol() !== 10309) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_protocol");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_target_port() !== 61462) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxservicebuilder_target_port");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_sandboxtemplaterefbuilder_new() !== 4748) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_sandboxtemplaterefbuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxtemplaterefbuilder_build() !== 46569) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxtemplaterefbuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_sandboxtemplaterefbuilder_name() !== 1803) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_sandboxtemplaterefbuilder_name");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_vmtemplatebuilder_new() !== 27302) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_vmtemplatebuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_args() !== 38529) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_args");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_build() !== 17867) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_claim_secrets() !== 62567) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_claim_secrets");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_command() !== 20371) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_command");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_container_disk_image() !== 49021) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_container_disk_image");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_cpu_cores() !== 25645) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_cpu_cores");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_env() !== 48368) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_env");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_firmware() !== 33926) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_firmware");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_image_pull_policy() !== 41828) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_image_pull_policy");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_image_pull_secret() !== 40154) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_image_pull_secret");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_memory() !== 55615) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_memory");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_nested_virtualization() !== 23834) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_nested_virtualization");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_node_selector() !== 45280) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_node_selector");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_oidc() !== 27280) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_oidc");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_probes() !== 40623) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_probes");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_process_mode() !== 49070) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_process_mode");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_runtime() !== 63375) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_runtime");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_runtime_class_name() !== 25466) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_runtime_class_name");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_services() !== 14113) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_services");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_tolerations() !== 1632) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_vmtemplatebuilder_tolerations");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_constructor_warmpoolautoscalingbuilder_new() !== 25769) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_constructor_warmpoolautoscalingbuilder_new");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_build() !== 17132) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_build");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_initial_pool_size() !== 56913) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_initial_pool_size");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_max_pool_size() !== 18359) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_max_pool_size");
+    }
+    if (nativeModule().ubrn_uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_min_pool_size() !== 46153) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_cyclops_sdk_schema_checksum_method_warmpoolautoscalingbuilder_min_pool_size");
+    }
+}
+export default Object.freeze({
+    initialize: uniffiEnsureInitialized,
+    converters: {
+        FfiConverterTypeClaimLifecycle,
+        FfiConverterTypeClaimSecretRef,
+        FfiConverterTypeClaimSpec,
+        FfiConverterTypeFirmware,
+        FfiConverterTypeImagePullPolicy,
+        FfiConverterTypeJsonValueError,
+        FfiConverterTypeOSGymSandboxClaimCondition,
+        FfiConverterTypeOSGymSandboxClaimSandbox,
+        FfiConverterTypeOSGymSandboxClaimStatus,
+        FfiConverterTypeOSGymSandboxSpec,
+        FfiConverterTypeOSGymSandboxStatus,
+        FfiConverterTypeOSGymSandboxTemplateSpec,
+        FfiConverterTypeOSGymSandboxTemplateSpecBuilder,
+        FfiConverterTypeOSGymSandboxWarmPoolSpec,
+        FfiConverterTypeOSGymSandboxWarmPoolSpecBuilder,
+        FfiConverterTypeOSGymSandboxWarmPoolStatus,
+        FfiConverterTypeOidcConfig,
+        FfiConverterTypePreservedJson,
+        FfiConverterTypeProcessMode,
+        FfiConverterTypeRuntimeKind,
+        FfiConverterTypeSandboxService,
+        FfiConverterTypeSandboxServiceBuilder,
+        FfiConverterTypeSandboxTemplateRef,
+        FfiConverterTypeSandboxTemplateRefBuilder,
+        FfiConverterTypeSchemaBuildError,
+        FfiConverterTypeServiceProtocol,
+        FfiConverterTypeVmTemplate,
+        FfiConverterTypeVmTemplateBuilder,
+        FfiConverterTypeWarmPoolAutoscaling,
+        FfiConverterTypeWarmPoolAutoscalingBuilder,
+        FfiConverterTypeWarmPoolTtlPolicy,
+    }
+});