langsmith 0.7.11 → 0.7.13

package/dist/_openapi_client/resources/sandboxes/boxes.js

@@ -0,0 +1,82 @@
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { APIResource } from '../../core/resource.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { path } from '../../internal/utils/path.js';
+export class Boxes extends APIResource {
+    /**
+     * Create a new sandbox from a snapshot. Provide at most one of `snapshot_id` or
+     * `snapshot_name`; if neither is provided, the server uses the default static
+     * blueprint.
+     */
+    create(body, options) {
+        return this._client.post('/v2/sandboxes/boxes', { body, ...options });
+    }
+    /**
+     * Retrieve a sandbox by name. Stale provisioning sandboxes are auto-failed.
+     */
+    retrieve(name, options) {
+        return this._client.get(path `/v2/sandboxes/boxes/${name}`, options);
+    }
+    /**
+     * Update a sandbox's display name. The name must be unique within the tenant.
+     */
+    update(name, body, options) {
+        return this._client.patch(path `/v2/sandboxes/boxes/${name}`, { body, ...options });
+    }
+    /**
+     * List sandboxes for the authenticated tenant, with optional filtering, sorting,
+     * and pagination.
+     */
+    list(query = {}, options) {
+        return this._client.get('/v2/sandboxes/boxes', { query, ...options });
+    }
+    /**
+     * Delete a sandbox by name or UUID. Tears down the sandbox runtime and removes the
+     * DB record.
+     */
+    delete(name, options) {
+        return this._client.delete(path `/v2/sandboxes/boxes/${name}`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+    /**
+     * Create a snapshot by capturing the current state of a sandbox or promoting an
+     * existing checkpoint.
+     */
+    createSnapshot(name, body, options) {
+        return this._client.post(path `/v2/sandboxes/boxes/${name}/snapshot`, { body, ...options });
+    }
+    /**
+     * Create a short-lived JWT for accessing an HTTP service running on a specific
+     * port inside a sandbox. Returns a browser_url (sets auth cookie via redirect), a
+     * service_url (for use with the X-Langsmith-Sandbox-Service-Token header), the raw
+     * token, and its expiry.
+     */
+    generateServiceURL(name, body, options) {
+        return this._client.post(path `/v2/sandboxes/boxes/${name}/service-url`, { body, ...options });
+    }
+    /**
+     * Retrieve the lightweight status of a sandbox for polling.
+     */
+    getStatus(name, options) {
+        return this._client.get(path `/v2/sandboxes/boxes/${name}/status`, options);
+    }
+    /**
+     * Start a stopped or failed sandbox. This endpoint is not idempotent.
+     */
+    start(name, options) {
+        return this._client.post(path `/v2/sandboxes/boxes/${name}/start`, options);
+    }
+    /**
+     * Stop a ready sandbox. This endpoint is not idempotent; the filesystem is
+     * preserved for later restart.
+     */
+    stop(name, options) {
+        return this._client.post(path `/v2/sandboxes/boxes/${name}/stop`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}

package/dist/_openapi_client/resources/sandboxes/registries.cjs

@@ -0,0 +1,44 @@
+"use strict";
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registries = void 0;
+const resource_js_1 = require("../../core/resource.cjs");
+const headers_js_1 = require("../../internal/headers.cjs");
+const path_js_1 = require("../../internal/utils/path.cjs");
+class Registries extends resource_js_1.APIResource {
+    /**
+     * Create a sandbox registry for pulling private images.
+     */
+    create(body, options) {
+        return this._client.post('/v2/sandboxes/registries', { body, ...options });
+    }
+    /**
+     * Get a sandbox registry by name.
+     */
+    retrieve(name, options) {
+        return this._client.get((0, path_js_1.path) `/v2/sandboxes/registries/${name}`, options);
+    }
+    /**
+     * Update a sandbox registry's name and/or credentials.
+     */
+    update(name, body, options) {
+        return this._client.patch((0, path_js_1.path) `/v2/sandboxes/registries/${name}`, { body, ...options });
+    }
+    /**
+     * List sandbox registries for pulling private images.
+     */
+    list(query = {}, options) {
+        return this._client.get('/v2/sandboxes/registries', { query, ...options });
+    }
+    /**
+     * Delete a sandbox registry by name.
+     */
+    delete(name, options) {
+        return this._client.delete((0, path_js_1.path) `/v2/sandboxes/registries/${name}`, {
+            ...options,
+            headers: (0, headers_js_1.buildHeaders)([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}
+exports.Registries = Registries;

package/dist/_openapi_client/resources/sandboxes/registries.d.ts

@@ -0,0 +1,67 @@
+import { APIResource } from '../../core/resource.js';
+import { APIPromise } from '../../core/api-promise.js';
+import { RequestOptions } from '../../internal/request-options.js';
+export declare class Registries extends APIResource {
+    /**
+     * Create a sandbox registry for pulling private images.
+     */
+    create(body: RegistryCreateParams, options?: RequestOptions): APIPromise<RegistryResponse>;
+    /**
+     * Get a sandbox registry by name.
+     */
+    retrieve(name: string, options?: RequestOptions): APIPromise<RegistryResponse>;
+    /**
+     * Update a sandbox registry's name and/or credentials.
+     */
+    update(name: string, body: RegistryUpdateParams, options?: RequestOptions): APIPromise<RegistryResponse>;
+    /**
+     * List sandbox registries for pulling private images.
+     */
+    list(query?: RegistryListParams | null | undefined, options?: RequestOptions): APIPromise<RegistryListResponse>;
+    /**
+     * Delete a sandbox registry by name.
+     */
+    delete(name: string, options?: RequestOptions): APIPromise<void>;
+}
+export interface RegistryListResponse {
+    offset?: number;
+    registries?: Array<RegistryResponse>;
+}
+export interface RegistryResponse {
+    id?: string;
+    created_at?: string;
+    created_by?: string;
+    name?: string;
+    updated_at?: string;
+    updated_by?: string;
+    url?: string;
+}
+export interface RegistryCreateParams {
+    name: string;
+    password: string;
+    url: string;
+    username: string;
+}
+export interface RegistryUpdateParams {
+    name?: string;
+    password?: string;
+    url?: string;
+    username?: string;
+}
+export interface RegistryListParams {
+    /**
+     * Maximum number of registries to return
+     */
+    limit?: number;
+    /**
+     * Filter to registries whose name contains this substring
+     */
+    name_contains?: string;
+    /**
+     * Number of registries to skip
+     */
+    offset?: number;
+}
+export declare namespace Registries {
+    export { type RegistryListResponse as RegistryListResponse, type RegistryResponse as RegistryResponse, type RegistryCreateParams as RegistryCreateParams, type RegistryUpdateParams as RegistryUpdateParams, type RegistryListParams as RegistryListParams, };
+}

package/dist/_openapi_client/resources/sandboxes/registries.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { APIResource } from '../../core/resource.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { path } from '../../internal/utils/path.js';
+export class Registries extends APIResource {
+    /**
+     * Create a sandbox registry for pulling private images.
+     */
+    create(body, options) {
+        return this._client.post('/v2/sandboxes/registries', { body, ...options });
+    }
+    /**
+     * Get a sandbox registry by name.
+     */
+    retrieve(name, options) {
+        return this._client.get(path `/v2/sandboxes/registries/${name}`, options);
+    }
+    /**
+     * Update a sandbox registry's name and/or credentials.
+     */
+    update(name, body, options) {
+        return this._client.patch(path `/v2/sandboxes/registries/${name}`, { body, ...options });
+    }
+    /**
+     * List sandbox registries for pulling private images.
+     */
+    list(query = {}, options) {
+        return this._client.get('/v2/sandboxes/registries', { query, ...options });
+    }
+    /**
+     * Delete a sandbox registry by name.
+     */
+    delete(name, options) {
+        return this._client.delete(path `/v2/sandboxes/registries/${name}`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}

package/dist/_openapi_client/resources/sandboxes/sandboxes.cjs

@@ -0,0 +1,72 @@
+"use strict";
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sandboxes = void 0;
+const resource_js_1 = require("../../core/resource.cjs");
+const BoxesAPI = __importStar(require("./boxes.cjs"));
+const boxes_js_1 = require("./boxes.cjs");
+const RegistriesAPI = __importStar(require("./registries.cjs"));
+const registries_js_1 = require("./registries.cjs");
+const SnapshotsAPI = __importStar(require("./snapshots.cjs"));
+const snapshots_js_1 = require("./snapshots.cjs");
+class Sandboxes extends resource_js_1.APIResource {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "boxes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new BoxesAPI.Boxes(this._client)
+        });
+        Object.defineProperty(this, "registries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new RegistriesAPI.Registries(this._client)
+        });
+        Object.defineProperty(this, "snapshots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SnapshotsAPI.Snapshots(this._client)
+        });
+    }
+}
+exports.Sandboxes = Sandboxes;
+Sandboxes.Boxes = boxes_js_1.Boxes;
+Sandboxes.Registries = registries_js_1.Registries;
+Sandboxes.Snapshots = snapshots_js_1.Snapshots;

package/dist/_openapi_client/resources/sandboxes/sandboxes.d.ts

@@ -0,0 +1,308 @@
+import { APIResource } from '../../core/resource.js';
+import * as BoxesAPI from './boxes.js';
+import { BoxCreateParams, BoxCreateSnapshotParams, BoxGenerateServiceURLParams, BoxListParams, BoxUpdateParams, Boxes } from './boxes.js';
+import * as RegistriesAPI from './registries.js';
+import { Registries, RegistryCreateParams, RegistryListParams, RegistryListResponse, RegistryResponse, RegistryUpdateParams } from './registries.js';
+import * as SnapshotsAPI from './snapshots.js';
+import { SnapshotCreateParams, SnapshotListParams, Snapshots } from './snapshots.js';
+export declare class Sandboxes extends APIResource {
+    boxes: BoxesAPI.Boxes;
+    registries: RegistriesAPI.Registries;
+    snapshots: SnapshotsAPI.Snapshots;
+}
+export interface SandboxListResponse {
+    offset?: number;
+    sandboxes?: Array<SandboxResponse>;
+}
+export interface SandboxResponse {
+    id?: string;
+    created_at?: string;
+    created_by?: string;
+    dataplane_url?: string;
+    delete_after_stop_seconds?: number;
+    fs_capacity_bytes?: number;
+    idle_ttl_seconds?: number;
+    mem_bytes?: number;
+    mount_config?: SandboxResponse.MountConfig;
+    name?: string;
+    proxy_config?: SandboxResponse.ProxyConfig;
+    size_class?: string;
+    snapshot_id?: string;
+    status?: string;
+    status_message?: string;
+    stopped_at?: string;
+    updated_at?: string;
+    updated_by?: string;
+    vcpus?: number;
+}
+export declare namespace SandboxResponse {
+    interface MountConfig {
+        auth?: MountConfig.Auth;
+        mounts?: Array<MountConfig.SandboxapiS3BucketMountSpec | MountConfig.SandboxapiGcsBucketMountSpec | MountConfig.SandboxapiGitRepoMountSpec>;
+    }
+    namespace MountConfig {
+        interface Auth {
+            aws?: Auth.Aws;
+            gcp?: Auth.Gcp;
+        }
+        namespace Auth {
+            interface Aws {
+                access_key_id: Aws.AccessKeyID;
+                secret_access_key: Aws.SecretAccessKey;
+            }
+            namespace Aws {
+                interface AccessKeyID {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+                interface SecretAccessKey {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Gcp {
+                service_account_json: Gcp.ServiceAccountJson;
+            }
+            namespace Gcp {
+                interface ServiceAccountJson {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+        }
+        interface SandboxapiS3BucketMountSpec {
+            id: string;
+            mount_path: string;
+            s3: SandboxapiS3BucketMountSpec.S3;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiS3BucketMountSpec.Cache;
+            gcs?: SandboxapiS3BucketMountSpec.Gcs;
+            git?: SandboxapiS3BucketMountSpec.Git;
+            read_only?: boolean;
+        }
+        namespace SandboxapiS3BucketMountSpec {
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+        }
+        interface SandboxapiGcsBucketMountSpec {
+            id: string;
+            gcs: SandboxapiGcsBucketMountSpec.Gcs;
+            mount_path: string;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiGcsBucketMountSpec.Cache;
+            git?: SandboxapiGcsBucketMountSpec.Git;
+            read_only?: boolean;
+            s3?: SandboxapiGcsBucketMountSpec.S3;
+        }
+        namespace SandboxapiGcsBucketMountSpec {
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+        }
+        interface SandboxapiGitRepoMountSpec {
+            id: string;
+            git: SandboxapiGitRepoMountSpec.Git;
+            mount_path: string;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiGitRepoMountSpec.Cache;
+            gcs?: SandboxapiGitRepoMountSpec.Gcs;
+            read_only?: boolean;
+            s3?: SandboxapiGitRepoMountSpec.S3;
+        }
+        namespace SandboxapiGitRepoMountSpec {
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+        }
+    }
+    interface ProxyConfig {
+        access_control?: ProxyConfig.AccessControl;
+        callbacks?: Array<ProxyConfig.Callback>;
+        no_proxy?: Array<string>;
+        rules?: Array<ProxyConfig.Rule>;
+    }
+    namespace ProxyConfig {
+        interface AccessControl {
+            allow_list?: Array<string>;
+            deny_list?: Array<string>;
+        }
+        interface Callback {
+            match_hosts: Array<string>;
+            ttl_seconds: number;
+            url: string;
+            full_request?: boolean;
+            request_headers?: Array<Callback.RequestHeader>;
+        }
+        namespace Callback {
+            interface RequestHeader {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+        interface Rule {
+            name: string;
+            aws?: Rule.Aws;
+            enabled?: boolean;
+            gcp?: Rule.Gcp;
+            headers?: Array<Rule.Header>;
+            /**
+             * MatchHosts is only accepted for header injection rules. Provider auth rules use
+             * built-in host matching.
+             */
+            match_hosts?: Array<string>;
+            match_paths?: Array<string>;
+            type?: string;
+        }
+        namespace Rule {
+            interface Aws {
+                access_key_id: Aws.AccessKeyID;
+                secret_access_key: Aws.SecretAccessKey;
+            }
+            namespace Aws {
+                interface AccessKeyID {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+                interface SecretAccessKey {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Gcp {
+                scopes: Array<string>;
+                service_account_json: Gcp.ServiceAccountJson;
+            }
+            namespace Gcp {
+                interface ServiceAccountJson {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Header {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+    }
+}
+export interface SandboxStatusResponse {
+    status?: string;
+    status_message?: string;
+}
+export interface ServiceURLResponse {
+    token?: string;
+    browser_url?: string;
+    expires_at?: string;
+    service_url?: string;
+}
+export interface SnapshotListResponse {
+    offset?: number;
+    snapshots?: Array<SnapshotResponse>;
+}
+export interface SnapshotResponse {
+    id?: string;
+    created_at?: string;
+    created_by?: string;
+    docker_image?: string;
+    fs_capacity_bytes?: number;
+    fs_used_bytes?: number;
+    image_digest?: string;
+    /**
+     * MemorySnapshotSizeBytes is non-nil iff the snapshot was captured with VM memory
+     * state. A non-nil value is the canonical signal that this snapshot can
+     * warm-restore from memory; nil means rootfs only.
+     */
+    memory_snapshot_size_bytes?: number;
+    name?: string;
+    registry_id?: string;
+    source_sandbox_id?: string;
+    status?: string;
+    status_message?: string;
+    updated_at?: string;
+}
+export declare namespace Sandboxes {
+    export { type SandboxListResponse as SandboxListResponse, type SandboxResponse as SandboxResponse, type SandboxStatusResponse as SandboxStatusResponse, type ServiceURLResponse as ServiceURLResponse, type SnapshotListResponse as SnapshotListResponse, type SnapshotResponse as SnapshotResponse, };
+    export { Boxes as Boxes, type BoxCreateParams as BoxCreateParams, type BoxUpdateParams as BoxUpdateParams, type BoxListParams as BoxListParams, type BoxCreateSnapshotParams as BoxCreateSnapshotParams, type BoxGenerateServiceURLParams as BoxGenerateServiceURLParams, };
+    export { Registries as Registries, type RegistryListResponse as RegistryListResponse, type RegistryResponse as RegistryResponse, type RegistryCreateParams as RegistryCreateParams, type RegistryUpdateParams as RegistryUpdateParams, type RegistryListParams as RegistryListParams, };
+    export { Snapshots as Snapshots, type SnapshotCreateParams as SnapshotCreateParams, type SnapshotListParams as SnapshotListParams, };
+}

package/dist/_openapi_client/resources/sandboxes/sandboxes.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { APIResource } from '../../core/resource.js';
+import * as BoxesAPI from './boxes.js';
+import { Boxes, } from './boxes.js';
+import * as RegistriesAPI from './registries.js';
+import { Registries, } from './registries.js';
+import * as SnapshotsAPI from './snapshots.js';
+import { Snapshots } from './snapshots.js';
+export class Sandboxes extends APIResource {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "boxes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new BoxesAPI.Boxes(this._client)
+        });
+        Object.defineProperty(this, "registries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new RegistriesAPI.Registries(this._client)
+        });
+        Object.defineProperty(this, "snapshots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new SnapshotsAPI.Snapshots(this._client)
+        });
+    }
+}
+Sandboxes.Boxes = Boxes;
+Sandboxes.Registries = Registries;
+Sandboxes.Snapshots = Snapshots;

package/dist/_openapi_client/resources/sandboxes/snapshots.cjs

@@ -0,0 +1,39 @@
+"use strict";
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Snapshots = void 0;
+const resource_js_1 = require("../../core/resource.cjs");
+const headers_js_1 = require("../../internal/headers.cjs");
+const path_js_1 = require("../../internal/utils/path.cjs");
+class Snapshots extends resource_js_1.APIResource {
+    /**
+     * Create a snapshot from a Docker image (async build).
+     */
+    create(body, options) {
+        return this._client.post('/v2/sandboxes/snapshots', { body, ...options });
+    }
+    /**
+     * Get a sandbox snapshot by ID.
+     */
+    retrieve(snapshotID, options) {
+        return this._client.get((0, path_js_1.path) `/v2/sandboxes/snapshots/${snapshotID}`, options);
+    }
+    /**
+     * List sandbox snapshots for the authenticated tenant, with optional filtering,
+     * sorting, and pagination.
+     */
+    list(query = {}, options) {
+        return this._client.get('/v2/sandboxes/snapshots', { query, ...options });
+    }
+    /**
+     * Delete a snapshot by ID. The underlying storage is reclaimed asynchronously.
+     */
+    delete(snapshotID, options) {
+        return this._client.delete((0, path_js_1.path) `/v2/sandboxes/snapshots/${snapshotID}`, {
+            ...options,
+            headers: (0, headers_js_1.buildHeaders)([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}
+exports.Snapshots = Snapshots;