@enclave-run/sdk 0.0.0-dev.4 → 0.0.0-dev.5

package/dist/index.d.ts

@@ -1605,10 +1605,13 @@ interface paths {
             path?: never;
             cookie?: never;
         };
-        /** @description Get desired and locally observed activation for one template region. */
+        /** @description Get desired and locally observed activation for one exact template build in a region. */
         get: {
             parameters: {
-                query?: never;
+                query?: {
+                    /** @description Exact immutable build generation. When omitted, the build selected by the template identifier's tag (default when untagged) is used. */
+                    buildID?: string;
+                };
                 header?: never;
                 path: {
                     region: string;
@@ -1858,6 +1861,92 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/templates/{templateID}/tags/{tag}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Get the authoritative build and version selected by one template tag. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    tag: string;
+                    templateID: components["parameters"]["templateID"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Current tag head. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TemplateTagHead"];
+                    };
+                };
+                400: components["responses"]["400"];
+                401: components["responses"]["401"];
+                403: components["responses"]["403"];
+                404: components["responses"]["404"];
+                409: components["responses"]["409"];
+                500: components["responses"]["500"];
+            };
+        };
+        /** @description Atomically move one template tag when its build and version still match. */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    tag: string;
+                    templateID: components["parameters"]["templateID"];
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["AssignTemplateTagHeadRequest"];
+                };
+            };
+            responses: {
+                /** @description Tag head advanced atomically. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TemplateTagHead"];
+                    };
+                };
+                400: components["responses"]["400"];
+                401: components["responses"]["401"];
+                403: components["responses"]["403"];
+                404: components["responses"]["404"];
+                /** @description Promotion precondition or candidate-state conflict. */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TemplateTagPromotionConflict"];
+                    };
+                };
+                500: components["responses"]["500"];
+            };
+        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/templates/aliases/{alias}": {
         parameters: {
             query?: never;
@@ -2427,6 +2516,23 @@ interface components {
             /** @description Assigned tags of the template */
             tags: string[];
         };
+        AssignTemplateTagHeadRequest: {
+            /**
+             * Format: uuid
+             * @description Exact ready, remotely durable build to select.
+             */
+            buildID: string;
+            /**
+             * Format: uuid
+             * @description Current build observed for the tag. Required when expectedVersion is greater than zero.
+             */
+            expectedBuildID?: string;
+            /**
+             * Format: int64
+             * @description Current tag-head version, or zero to require an absent tag.
+             */
+            expectedVersion: number;
+        };
         AssignTemplateTagsRequest: {
             /** @description Tags to assign to the template */
             tags: string[];
@@ -2684,6 +2790,11 @@ interface components {
         ListedSandbox: {
             /** @description Alias of the template */
             alias?: string;
+            /**
+             * Format: uuid
+             * @description Identifier of the exact immutable template build generation used by the sandbox
+             */
+            buildID: string;
             cpuCount: components["schemas"]["CPUCount"];
             diskSizeMB: components["schemas"]["DiskSizeMB"];
             /**
@@ -2990,6 +3101,11 @@ interface components {
         Sandbox: {
             /** @description Alias of the template */
             alias?: string;
+            /**
+             * Format: uuid
+             * @description Identifier of the exact immutable template build generation booted by the sandbox
+             */
+            buildID: string;
             capacityTier: components["schemas"]["SandboxCapacityTier"];
             /** @description Base domain where the sandbox traffic is accessible */
             domain?: string | null;
@@ -3088,6 +3204,11 @@ interface components {
         SandboxDetail: {
             /** @description Alias of the template */
             alias?: string;
+            /**
+             * Format: uuid
+             * @description Identifier of the exact immutable template build generation used by the sandbox
+             */
+            buildID: string;
             cpuCount: components["schemas"]["CPUCount"];
             diskSizeMB: components["schemas"]["DiskSizeMB"];
             /** @description Base domain where the sandbox traffic is accessible */
@@ -3193,7 +3314,7 @@ interface components {
             /** @description List of allowed CIDR blocks or IP addresses for egress traffic. Allowed addresses always take precedence over blocked addresses. */
             allowOut?: string[];
             /**
-             * @description Specify if the sandbox URLs should be accessible only with authentication.
+             * @description Whether sandbox URLs are publicly reachable without a traffic access token. Set false to require authenticated proxy access.
              * @default true
              */
             allowPublicTraffic?: boolean;
@@ -3596,6 +3717,11 @@ interface components {
              * @description Exact immutable build generation to materialize.
              */
             buildID: string;
+            /**
+             * Format: int64
+             * @description Compare-and-swap precondition for this exact build activation. Use 0 to require that it does not yet exist, or the last observed version to update it.
+             */
+            expectedVersion?: number;
             /**
              * Format: int32
              * @default 1
@@ -3645,6 +3771,20 @@ interface components {
             /** @description The tag name */
             tag: string;
         };
+        TemplateTagHead: {
+            /** Format: uuid */
+            buildID: string;
+            /** Format: date-time */
+            createdAt: string;
+            tag: string;
+            /** Format: int64 */
+            version: number;
+        };
+        TemplateTagPromotionConflict: {
+            /** @enum {string} */
+            code: "candidate_not_promotable" | "tag_changed" | "concurrent_mutation" | "global_api_required";
+            message: string;
+        };
         TemplateUpdateRequest: {
             /** @description Whether the template is public or only accessible by the team */
             public?: boolean;
@@ -4072,6 +4212,30 @@ declare class GitUpstreamError extends SandboxError {
 declare class TemplateError extends SandboxError {
     constructor(message: string, stackTrace?: string);
 }
+type TemplateTagConflictReason = "tag_changed" | "concurrent_mutation";
+/**
+ * A concurrent template tag mutation prevented an atomic promotion.
+ *
+ * Fetch the current head with `Template.getTagHead`, decide whether the
+ * promotion is still appropriate, and retry with that newly observed token.
+ */
+declare class TemplateTagConflictError extends TemplateError {
+    readonly templateId: string;
+    readonly tag: string;
+    readonly candidateBuildId: string;
+    readonly expectedBuildId?: string;
+    readonly expectedVersion: number;
+    readonly reason: TemplateTagConflictReason;
+    constructor(options: {
+        templateId: string;
+        tag: string;
+        candidateBuildId: string;
+        expectedBuildId?: string;
+        expectedVersion: number;
+        reason: TemplateTagConflictReason;
+        message?: string;
+    });
+}
 /**
  * Thrown when the API rate limit is exceeded.
  */
@@ -7176,7 +7340,8 @@ type SandboxNetworkOpts = {
      */
     denyOut?: string[];
     /**
-     * Specify if the sandbox URLs should be accessible only with authentication.
+     * Whether sandbox URLs are publicly reachable without a traffic access
+     * token. Set false to require authenticated proxy access.
      * @default true
      */
     allowPublicTraffic?: boolean;
@@ -7291,6 +7456,19 @@ type SandboxConnectOpts = ConnectionOpts & {
      */
     timeoutMs?: number;
 };
+/**
+ * Serializable locator for reconnecting to a sandbox through its owning
+ * regional API.
+ */
+interface SandboxRef {
+    readonly sandboxId: string;
+    readonly region: string;
+}
+/**
+ * A sandbox can be addressed by a complete regional reference or, for
+ * backwards compatibility, by its opaque ID plus connection options.
+ */
+type SandboxTarget = string | SandboxRef;
 /**
  * State of the sandbox.
  */
@@ -7366,6 +7544,10 @@ interface SandboxInfo {
      * Sandbox ID.
      */
     sandboxId: string;
+    /**
+     * Exact immutable template build generation used by the sandbox.
+     */
+    buildId: string;
     /**
      * Template ID.
      */
@@ -7452,7 +7634,7 @@ declare class SandboxApi {
      *
      * @returns `true` if the sandbox was found and killed, `false` otherwise.
      */
-    static kill(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>;
+    static kill(target: SandboxTarget, opts?: SandboxApiOpts): Promise<boolean>;
     /**
      * Get sandbox information like sandbox ID, template, metadata, started at/end at date.
      *
@@ -7461,7 +7643,7 @@ declare class SandboxApi {
      *
      * @returns sandbox information.
      */
-    static getInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>;
+    static getInfo(target: SandboxTarget, opts?: SandboxApiOpts): Promise<SandboxInfo>;
     /**
      * Get the metrics of the sandbox.
      *
@@ -7470,7 +7652,7 @@ declare class SandboxApi {
      *
      * @returns  List of sandbox metrics containing CPU, memory and disk usage information.
      */
-    static getMetrics(sandboxId: string, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
+    static getMetrics(target: SandboxTarget, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     /**
      * Set the timeout of the specified sandbox.
      * After the timeout expires the sandbox will be automatically killed.
@@ -7483,8 +7665,8 @@ declare class SandboxApi {
      * @param timeoutMs timeout in **milliseconds**.
      * @param opts connection options.
      */
-    static setTimeout(sandboxId: string, timeoutMs: number, opts?: SandboxApiOpts): Promise<void>;
-    static getFullInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<{
+    static setTimeout(target: SandboxTarget, timeoutMs: number, opts?: SandboxApiOpts): Promise<void>;
+    static getFullInfo(target: SandboxTarget, opts?: SandboxApiOpts): Promise<{
         metadata: {
             [key: string]: string;
         };
@@ -7499,6 +7681,7 @@ declare class SandboxApi {
         sandboxRegion: string;
         name?: string | undefined;
         sandboxId: string;
+        buildId: string;
         templateId: string;
     }>;
     /**
@@ -7509,7 +7692,7 @@ declare class SandboxApi {
      *
      * @returns `true` if the sandbox got paused, `false` if the sandbox was already paused.
      */
-    static pause(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>;
+    static pause(target: SandboxTarget, opts?: SandboxApiOpts): Promise<boolean>;
     /**
      * Create a snapshot from a sandbox.
      *
@@ -7522,7 +7705,7 @@ declare class SandboxApi {
      *
      * @returns snapshot information including the snapshot name that can be used with Sandbox.create().
      */
-    static createSnapshot(sandboxId: string, opts?: SandboxApiOpts): Promise<SnapshotInfo>;
+    static createSnapshot(target: SandboxTarget, opts?: SandboxApiOpts): Promise<SnapshotInfo>;
     /**
      * List all snapshots.
      *
@@ -7542,6 +7725,7 @@ declare class SandboxApi {
     static deleteSnapshot(snapshotId: string, opts?: SandboxApiOpts): Promise<boolean>;
     protected static createSandbox(template: string, timeoutMs: number, opts?: SandboxOpts): Promise<{
         sandboxId: string;
+        buildId: string;
         sandboxDomain: string | undefined;
         sandboxRegion: string;
         capacityTier: "shared";
@@ -7550,9 +7734,22 @@ declare class SandboxApi {
         envdAccessToken: string | undefined;
         trafficAccessToken: string | undefined;
     }>;
+    protected static recoverSandboxCreate(recovery: SandboxCreateRecovery, opts?: SandboxOpts): Promise<{
+        sandboxId: string;
+        buildId: string;
+        sandboxDomain: string | undefined;
+        sandboxRegion: string;
+        capacityTier: "shared";
+        apiUrl: string;
+        envdVersion: string;
+        envdAccessToken: string | undefined;
+        trafficAccessToken: string | undefined;
+    }>;
+    private static sandboxInfoFromCreate;
     private static waitForSandboxCreate;
-    protected static connectSandbox(sandboxId: string, opts?: SandboxConnectOpts): Promise<{
+    protected static connectSandbox(target: SandboxTarget, opts?: SandboxConnectOpts): Promise<{
         sandboxId: string;
+        buildId: string;
         sandboxDomain: string | undefined;
         sandboxRegion: string;
         capacityTier: "shared";
@@ -8521,6 +8718,14 @@ declare class Sandbox extends SandboxApi {
      * Unique identifier of the sandbox.
      */
     readonly sandboxId: string;
+    /**
+     * Serializable regional reference for reconnecting to this sandbox.
+     */
+    get ref(): SandboxRef;
+    /**
+     * Identifier of the exact immutable template build generation booted by this sandbox.
+     */
+    readonly buildId: string;
     /**
      * Domain where the sandbox is hosted.
      */
@@ -8554,6 +8759,7 @@ declare class Sandbox extends SandboxApi {
      */
     constructor(opts: SandboxConnectOpts & {
         sandboxId: string;
+        buildId: string;
         sandboxDomain?: string;
         sandboxRegion: string;
         capacityTier: "shared";
@@ -8561,6 +8767,7 @@ declare class Sandbox extends SandboxApi {
         envdAccessToken?: string;
         trafficAccessToken?: string;
     });
+    private connectionOptions;
     /**
      * List all sandboxes.
      *
@@ -8569,6 +8776,18 @@ declare class Sandbox extends SandboxApi {
      * @returns paginator for listing sandboxes.
      */
     static list(opts?: SandboxListOpts): SandboxPaginator;
+    /**
+     * Create an immutable regional scope so repeated sandbox operations do not
+     * need to repeat the same region option.
+     *
+     * @example
+     * ```ts
+     * const yyz = Sandbox.inRegion("yyz")
+     * const sandbox = await yyz.create()
+     * const sameSandbox = await yyz.connect(sandbox.sandboxId)
+     * ```
+     */
+    static inRegion<S extends typeof Sandbox>(this: S, region: string): SandboxRegionScope<S>;
     /**
      * Create a new sandbox from the default `base` sandbox template.
      *
@@ -8598,6 +8817,26 @@ declare class Sandbox extends SandboxApi {
      * @constructs {@link Sandbox}
      */
     static create<S extends typeof Sandbox>(this: S, template: string, opts?: SandboxOpts): Promise<InstanceType<S>>;
+    /**
+     * Recover a create whose authoritative response was lost without resending
+     * the original create payload.
+     *
+     * Pass `OutcomeUnknownError.recovery`. Recovery is pinned to the operation's
+     * owning region and cannot create a second sandbox with different options.
+     *
+     * @example
+     * ```ts
+     * try {
+     *   return await Sandbox.create("base", { idempotencyKey: "job-123" })
+     * } catch (error) {
+     *   if (error instanceof OutcomeUnknownError) {
+     *     return Sandbox.recoverCreate(error.recovery)
+     *   }
+     *   throw error
+     * }
+     * ```
+     */
+    static recoverCreate<S extends typeof Sandbox>(this: S, recovery: SandboxCreateRecovery, opts?: SandboxOpts): Promise<InstanceType<S>>;
     /**
      * @beta This feature is in beta and may change in the future.
      *
@@ -8635,9 +8874,11 @@ declare class Sandbox extends SandboxApi {
      * Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.
      * Sandbox must be either running or be paused.
      *
-     * With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
+     * Persist {@link Sandbox.ref} to reconnect through the sandbox's owning
+     * regional API from another process or environment.
      *
-     * @param sandboxId sandbox ID.
+     * @param target sandbox ID, or a serializable reference containing its ID
+     * and owning region.
      * @param opts connection options.
      *
      * @returns A running sandbox instance
@@ -8651,7 +8892,7 @@ declare class Sandbox extends SandboxApi {
      * const sameSandbox = await Sandbox.connect(sandboxId)
      * ```
      */
-    static connect<S extends typeof Sandbox>(this: S, sandboxId: string, opts?: SandboxConnectOpts): Promise<InstanceType<S>>;
+    static connect<S extends typeof Sandbox>(this: S, target: SandboxTarget, opts?: SandboxConnectOpts): Promise<InstanceType<S>>;
     /**
      * Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.
      * Sandbox must be either running or be paused.
@@ -8822,6 +9063,51 @@ declare class Sandbox extends SandboxApi {
     getMetrics(opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>;
     private fileUrl;
 }
+type Scoped<T> = Omit<T, "region">;
+/**
+ * Immutable facade over Sandbox's static API, pinned to one region.
+ * Construct it with {@link Sandbox.inRegion}.
+ */
+declare class SandboxRegionScope<S extends typeof Sandbox = typeof Sandbox> {
+    private readonly sandboxClass;
+    private readonly selectedRegion;
+    constructor(sandboxClass: S, region: string);
+    get region(): string;
+    private options;
+    list(opts?: Scoped<SandboxListOpts>): SandboxPaginator;
+    create(opts?: Scoped<SandboxOpts>): Promise<InstanceType<S>>;
+    create(template: string, opts?: Scoped<SandboxOpts>): Promise<InstanceType<S>>;
+    recoverCreate(recovery: SandboxCreateRecovery, opts?: Scoped<SandboxOpts>): Promise<InstanceType<S>>;
+    betaCreate(opts?: Scoped<SandboxOpts>): Promise<InstanceType<S>>;
+    betaCreate(template: string, opts?: Scoped<SandboxOpts>): Promise<InstanceType<S>>;
+    connect(target: SandboxTarget, opts?: Scoped<SandboxConnectOpts>): Promise<InstanceType<S>>;
+    kill(target: SandboxTarget, opts?: Scoped<SandboxApiOpts>): Promise<boolean>;
+    getInfo(target: SandboxTarget, opts?: Scoped<SandboxApiOpts>): Promise<SandboxInfo>;
+    getFullInfo(target: SandboxTarget, opts?: Scoped<SandboxApiOpts>): Promise<{
+        metadata: {
+            [key: string]: string;
+        };
+        envdVersion: string;
+        envdAccessToken: string | undefined;
+        startedAt: Date;
+        endAt: Date;
+        state: "running" | "paused";
+        cpuCount: number;
+        memoryMB: number;
+        sandboxDomain: string | undefined;
+        sandboxRegion: string;
+        name?: string | undefined;
+        sandboxId: string;
+        buildId: string;
+        templateId: string;
+    }>;
+    getMetrics(target: SandboxTarget, opts?: Scoped<SandboxMetricsOpts>): Promise<SandboxMetrics[]>;
+    setTimeout(target: SandboxTarget, timeoutMs: number, opts?: Scoped<SandboxApiOpts>): Promise<void>;
+    pause(target: SandboxTarget, opts?: Scoped<SandboxApiOpts>): Promise<boolean>;
+    createSnapshot(target: SandboxTarget, opts?: Scoped<SandboxApiOpts>): Promise<SnapshotInfo>;
+    listSnapshots(opts?: Scoped<SnapshotListOpts>): SnapshotPaginator;
+    deleteSnapshot(snapshotId: string, opts?: Scoped<SandboxApiOpts>): Promise<boolean>;
+}
 
 /**
  * Class for ready check commands.
@@ -9104,6 +9390,12 @@ type TemplateActivationOptions = ConnectionOpts & {
      * @default false
      */
     allowRemoteFallback?: boolean;
+    /**
+     * Compare-and-swap precondition for this exact build activation.
+     * Use `0` to require a new activation, or the last observed version when
+     * changing one.
+     */
+    expectedVersion?: number;
 };
 type GetTemplateActivationOptions = ConnectionOpts & {
     /**
@@ -9111,6 +9403,23 @@ type GetTemplateActivationOptions = ConnectionOpts & {
      * @default ENCLAVE_REGION, then yyz
      */
     region?: string;
+    /**
+     * Exact immutable build generation whose regional state should be returned.
+     * When omitted, Enclave resolves the tag in `templateId` (`default` when
+     * untagged) for compatibility with existing callers.
+     */
+    buildId?: string;
+};
+type DeactivateTemplateOptions = ConnectionOpts & {
+    /**
+     * Region in which the exact build generation should be deactivated.
+     * @default ENCLAVE_REGION, then yyz
+     */
+    region?: string;
+    /**
+     * Compare-and-swap precondition using the last observed activation version.
+     */
+    expectedVersion?: number;
 };
 /**
  * Information about assigned template tags.
@@ -9142,6 +9451,33 @@ type TemplateTag = {
      */
     createdAt: Date;
 };
+/**
+ * Authoritative traffic-selection token for one template tag.
+ */
+type TemplateTagHead = {
+    /**
+     * Name of the tag.
+     */
+    tag: string;
+    /**
+     * Exact build currently selected by the tag.
+     */
+    buildId: string;
+    /**
+     * Monotonic version used to fence concurrent promotion attempts.
+     */
+    version: number;
+    /**
+     * When this head was assigned.
+     */
+    createdAt: Date;
+};
+/**
+ * The previously observed tag head required for a safe promotion.
+ *
+ * Pass `null` to require that the tag does not yet exist.
+ */
+type TemplateTagHeadExpectation = Pick<TemplateTagHead, "buildId" | "version"> | null;
 /**
  * Configuration for a single file/directory copy operation.
  */
@@ -9779,7 +10115,7 @@ declare class TemplateBase implements TemplateFromImage, TemplateBuilder, Templa
     /**
      * Stop pinning and maintaining one exact build generation in a region.
      */
-    static deactivate(data: Pick<BuildInfo, "templateId" | "buildId">, options?: GetTemplateActivationOptions): Promise<TemplateRegionActivation>;
+    static deactivate(data: Pick<BuildInfo, "templateId" | "buildId">, options?: DeactivateTemplateOptions): Promise<TemplateRegionActivation>;
     /**
      * Check if a template with the given name exists.
      *
@@ -9847,6 +10183,23 @@ declare class TemplateBase implements TemplateFromImage, TemplateBuilder, Templa
      * ```
      */
     static getTags(templateId: string, options?: ConnectionOpts): Promise<TemplateTag[]>;
+    /**
+     * Get the authoritative traffic-selection token for one template tag.
+     *
+     * Pass the returned head directly to {@link promoteTag}; its monotonic
+     * version prevents concurrent releasers from silently overwriting each
+     * other.
+     */
+    static getTagHead(templateId: string, tag: string, options?: ConnectionOpts): Promise<TemplateTagHead>;
+    /**
+     * Atomically move one template tag to an exact ready, durable build.
+     *
+     * Use a head returned by {@link getTagHead} as `expected`. Pass `null` only
+     * when creating a tag that must not already exist. A concurrent change throws
+     * `TemplateTagConflictError`; fetch the head again before deciding whether to
+     * retry.
+     */
+    static promoteTag(candidate: Pick<BuildInfo, "templateId" | "buildId">, tag: string, expected: TemplateTagHeadExpectation, options?: ConnectionOpts): Promise<TemplateTagHead>;
     fromDebianImage(variant?: string): TemplateBuilder;
     fromUbuntuImage(variant?: string): TemplateBuilder;
     fromPythonImage(version?: string): TemplateBuilder;
@@ -10024,8 +10377,10 @@ declare namespace Template {
     var assignTags: typeof TemplateBase.assignTags;
     var removeTags: typeof TemplateBase.removeTags;
     var getTags: typeof TemplateBase.getTags;
+    var getTagHead: typeof TemplateBase.getTagHead;
+    var promoteTag: typeof TemplateBase.promoteTag;
     var toJSON: typeof TemplateBase.toJSON;
     var toDockerfile: typeof TemplateBase.toDockerfile;
 }
 
-export { ALL_TRAFFIC, ApiClient, AuthenticationError, BuildError, type BuildInfo, type BuildOptions, type BuildStatusReason, type CommandConnectOpts, CommandExitError, CommandHandle, type CommandRequestOpts, type CommandResult, type CommandStartOpts, Commands, ConnectionConfig, type ConnectionOpts, type CopyItem, type CredentialAuditEvent, type EntryInfo, FileType, FileUploadError, Filesystem, type FilesystemEvent, FilesystemEventType, type GetBuildStatusOptions, type GetTemplateActivationOptions, Git, type GitAddOpts, GitAuthError, type GitBranches, type GitCloneOpts, type GitCommitOpts, type GitConfigOpts, type GitConfigScope, type GitDangerouslyAuthenticateOpts, type GitDeleteBranchOpts, type GitFileStatus, GitHubApp, type GitHubAuditQuery, type GitHubCredentialGrant, type GitHubGrantScope, type GitHubInstallation, type GitHubInstallationCallback, type GitHubInstallationLink, type GitHubRepositoryBinding, type GitHubRepositoryBindingOpts, type GitHubRepositoryPermissions, type GitInitOpts, type GitPullOpts, type GitPushOpts, type GitRemoteAddOpts, type GitRequestOpts, type GitStatus, GitUpstreamError, IdempotencyMismatchError, InvalidArgumentError, LogEntry, LogEntryEnd, type LogEntryLevel, LogEntryStart, type Logger, type McpServer$1 as McpServer, type McpServerName, NotEnoughSpaceError, NotFoundError, OutcomeUnknownError, type ProcessInfo, Pty, type PtyOutput, RateLimitError, ReadyCmd, RegionCapacityError, Sandbox, type SandboxApiOpts, type SandboxConnectOpts, type SandboxCreateRecovery, SandboxCreateRejectedError, type SandboxCreateRejectionReason, SandboxError, type SandboxInfo, type SandboxLifecycle, type SandboxListOpts, type SandboxMetrics, type SandboxMetricsOpts, type SandboxNetworkOpts, type SandboxOpts, SandboxPaginator, type SandboxState, type SnapshotInfo, type SnapshotListOpts, SnapshotPaginator, type Stderr, type Stdout, Template, type TemplateActivationOptions, TemplateBase, type TemplateBuildStatus, type TemplateBuildStatusResponse, type TemplateBuilder, type TemplateClass, TemplateError, type TemplateRegionActivation, type TemplateTag, type TemplateTagInfo, TimeoutError, type Username, WatchHandle, type WriteInfo, type components, Sandbox as default, defaultBuildLogger, getSignature, type paths, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL };
+export { ALL_TRAFFIC, ApiClient, AuthenticationError, BuildError, type BuildInfo, type BuildOptions, type BuildStatusReason, type CommandConnectOpts, CommandExitError, CommandHandle, type CommandRequestOpts, type CommandResult, type CommandStartOpts, Commands, ConnectionConfig, type ConnectionOpts, type CopyItem, type CredentialAuditEvent, type DeactivateTemplateOptions, type EntryInfo, FileType, FileUploadError, Filesystem, type FilesystemEvent, FilesystemEventType, type GetBuildStatusOptions, type GetTemplateActivationOptions, Git, type GitAddOpts, GitAuthError, type GitBranches, type GitCloneOpts, type GitCommitOpts, type GitConfigOpts, type GitConfigScope, type GitDangerouslyAuthenticateOpts, type GitDeleteBranchOpts, type GitFileStatus, GitHubApp, type GitHubAuditQuery, type GitHubCredentialGrant, type GitHubGrantScope, type GitHubInstallation, type GitHubInstallationCallback, type GitHubInstallationLink, type GitHubRepositoryBinding, type GitHubRepositoryBindingOpts, type GitHubRepositoryPermissions, type GitInitOpts, type GitPullOpts, type GitPushOpts, type GitRemoteAddOpts, type GitRequestOpts, type GitStatus, GitUpstreamError, IdempotencyMismatchError, InvalidArgumentError, LogEntry, LogEntryEnd, type LogEntryLevel, LogEntryStart, type Logger, type McpServer$1 as McpServer, type McpServerName, NotEnoughSpaceError, NotFoundError, OutcomeUnknownError, type ProcessInfo, Pty, type PtyOutput, RateLimitError, ReadyCmd, RegionCapacityError, Sandbox, type SandboxApiOpts, type SandboxConnectOpts, type SandboxCreateRecovery, SandboxCreateRejectedError, type SandboxCreateRejectionReason, SandboxError, type SandboxInfo, type SandboxLifecycle, type SandboxListOpts, type SandboxMetrics, type SandboxMetricsOpts, type SandboxNetworkOpts, type SandboxOpts, SandboxPaginator, type SandboxRef, SandboxRegionScope, type SandboxState, type SandboxTarget, type SnapshotInfo, type SnapshotListOpts, SnapshotPaginator, type Stderr, type Stdout, Template, type TemplateActivationOptions, TemplateBase, type TemplateBuildStatus, type TemplateBuildStatusResponse, type TemplateBuilder, type TemplateClass, TemplateError, type TemplateRegionActivation, type TemplateTag, TemplateTagConflictError, type TemplateTagConflictReason, type TemplateTagHead, type TemplateTagHeadExpectation, type TemplateTagInfo, TimeoutError, type Username, WatchHandle, type WriteInfo, type components, Sandbox as default, defaultBuildLogger, getSignature, type paths, waitForFile, waitForPort, waitForProcess, waitForTimeout, waitForURL };