Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

144 KB
Raw Blame
/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/default-templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List default templates
         * @description Lists the platform's default templates, ordered by template ID. Deleted templates are left out. Templates that are not public are listed only to their own team and to admin callers. The build, resources and envd version are those of the newest ready build tagged `default`, the one a sandbox started from the template runs, and are zero or empty when there is none; `buildStatus` describes the newest build tagged `default` in any state. Usage fields (`spawnCount`, `buildCount`, `lastSpawnedAt`, `createdBy`) are reported only for the caller's own templates and to admin callers.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the default templates */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Template"][];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List running sandboxes
         * @deprecated
         * @description List all running sandboxes. Use GET /v2/sandboxes instead.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Metadata query used to filter the sandboxes (e.g. "user=abc&app=prod"). Each key and values must be URL encoded. */
                    metadata?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all running sandboxes */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListedSandbox"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /**
         * Create sandbox
         * @deprecated
         * @description Create a sandbox from the template. All system communication with the sandbox is secured. Use POST /v2/sandboxes instead.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["NewSandbox"];
                };
            };
            responses: {
                /** @description The sandbox was created successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
                504: components["responses"]["504"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Sandbox
         * @description Get a sandbox by id
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the sandbox */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxDetail"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        /**
         * Kill sandbox
         * @description Kill a sandbox
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description The sandbox was killed successfully */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/connect": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Connect sandbox
         * @deprecated
         * @description Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended. Use POST /v2/sandboxes/{sandboxID}/connect instead.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["ConnectSandbox"];
                };
            };
            responses: {
                /** @description The sandbox was already running */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                /** @description The sandbox was resumed successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
                504: components["responses"]["504"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/fork": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Fork sandbox
         * @description Fork the sandbox: checkpoint the running sandbox in place (it is briefly paused, snapshotted with its full memory state, and resumed on its node, keeping its ID and expiration untouched) and create count new sandboxes from that snapshot. Returns one result per requested fork, each carrying either the created sandbox or the error that prevented it from starting. A non-201 status means the request failed before any fork was attempted.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["SandboxForkRequest"];
                };
            };
            responses: {
                /** @description The sandbox was snapshotted and the forks were attempted; each entry reports one fork's outcome */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxForkResult"][];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Sandbox logs
         * @deprecated
         * @description Get sandbox logs. Use /v2/sandboxes/{sandboxID}/logs instead.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of logs that should be returned */
                    limit?: number;
                    /** @description Starting timestamp of the logs that should be returned in milliseconds */
                    start?: number;
                };
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the sandbox logs */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxLogs"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Sandbox metrics
         * @description Get sandbox metrics
         */
        get: {
            parameters: {
                query?: {
                    end?: number;
                    /** @description Unix timestamp for the start of the interval, in seconds, for which the metrics */
                    start?: number;
                };
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the sandbox metrics */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxMetric"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/network": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /**
         * Update sandbox network
         * @description Update the network configuration for a running sandbox. Replaces the current egress rules with the provided configuration. Omitting field clears it.
         */
        put: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["SandboxNetworkUpdateConfig"];
                };
            };
            responses: {
                /** @description Successfully updated the sandbox network configuration */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/pause": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Pause sandbox
         * @description Pause the sandbox
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["SandboxPauseRequest"];
                };
            };
            responses: {
                /** @description The sandbox was paused successfully and can be resumed */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/refreshes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Refresh sandbox
         * @description Refresh the sandbox extending its time to live
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["SandboxRefreshRequest"];
                };
            };
            responses: {
                /** @description Successfully refreshed the sandbox */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/resume": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Resume sandbox
         * @deprecated
         * @description Resume the sandbox
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ResumedSandbox"];
                };
            };
            responses: {
                /** @description The sandbox was resumed successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
                504: components["responses"]["504"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/snapshots": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create snapshot
         * @description Create a persistent snapshot from the sandbox's current state. Snapshots can be used to create new sandboxes and persist beyond the original sandbox's lifetime.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["SandboxSnapshotRequest"];
                };
            };
            responses: {
                /** @description Snapshot created successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SnapshotInfo"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/timeout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set sandbox timeout
         * @description Set the timeout for the sandbox. The sandbox will expire x seconds from the time of the request. Calling this method multiple times overwrites the TTL, each time using the current timestamp as the starting point to measure the timeout duration.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["SandboxTimeoutRequest"];
                };
            };
            responses: {
                /** @description Successfully set the sandbox timeout */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List sandbox metrics
         * @description List metrics for given sandboxes
         */
        get: {
            parameters: {
                query: {
                    /** @description Comma-separated list of sandbox IDs to get metrics for */
                    sandbox_ids: string[];
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all running sandboxes with metrics */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxesWithMetrics"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List project secrets
         * @description List the project's secrets. No response carries a secret value.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of items to return per page */
                    limit?: components["parameters"]["paginationLimit"];
                    /** @description Cursor to start the list from */
                    nextToken?: components["parameters"]["paginationNextToken"];
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully listed the project's secrets */
                200: {
                    headers: {
                        "X-Next-Token": components["headers"]["XNextToken"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Secret"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                502: components["responses"]["502"];
                504: components["responses"]["504"];
            };
        };
        put?: never;
        /**
         * Create a secret
         * @description Create a secret by storing a runtime marker as its first version. The response carries metadata only.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["NewSecret"];
                };
            };
            responses: {
                /** @description Successfully created the secret */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Secret"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                /** @description Secret name conflict or project live-secret limit reached. A quota response has error_code secret_limit_reached and, when reported by the backend, the effective cap in message. */
                409: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                502: components["responses"]["502"];
                504: components["responses"]["504"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets/{secretID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get a secret
         * @description Get one secret's metadata, selected by identifier or name.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    secretID: components["parameters"]["secretID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully retrieved the secret */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Secret"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                502: components["responses"]["502"];
                504: components["responses"]["504"];
            };
        };
        put?: never;
        /**
         * Update a secret
         * @description Replace the secret's stored marker by appending a new version. The response carries metadata only.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    secretID: components["parameters"]["secretID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["SecretUpdate"];
                };
            };
            responses: {
                /** @description Successfully updated the secret */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Secret"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                502: components["responses"]["502"];
                504: components["responses"]["504"];
            };
        };
        /**
         * Delete a secret
         * @description Revoke the secret and schedule its versions for cleanup.
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    secretID: components["parameters"]["secretID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully deleted the secret */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                502: components["responses"]["502"];
                504: components["responses"]["504"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/snapshots": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List snapshots
         * @description List all snapshots for the team
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of items to return per page */
                    limit?: components["parameters"]["paginationLimit"];
                    /** @description Filter snapshots by name or ID, optionally tag-qualified (e.g. "my-snapshot", "my-team/my-snapshot" or "my-snapshot:v1"). */
                    name?: string;
                    /** @description Cursor to start the list from */
                    nextToken?: components["parameters"]["paginationNextToken"];
                    sandboxID?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned snapshots */
                200: {
                    headers: {
                        "X-Next-Token": components["headers"]["XNextToken"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SnapshotInfo"][];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/teams": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List teams
         * @description List all teams
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all teams */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Team"][];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/teams/{teamID}/limits": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get team limits
         * @description Returns the team's effective resource limits. A team-authenticated request may read only its own team.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /** @description Identifier of the team, as its UUID or its public project ID (prj_) */
                    teamID: components["parameters"]["teamID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the team limits */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TeamLimitsResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/teams/{teamID}/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Team metrics
         * @description Get metrics for the team
         */
        get: {
            parameters: {
                query?: {
                    end?: number;
                    /** @description Unix timestamp for the start of the interval, in seconds, for which the metrics */
                    start?: number;
                };
                header?: never;
                path: {
                    /** @description Identifier of the team, as its UUID or its public project ID (prj_) */
                    teamID: components["parameters"]["teamID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the team metrics */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TeamMetric"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/teams/{teamID}/metrics/max": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Maximum team metrics
         * @description Get the maximum metrics for the team in the given interval
         */
        get: {
            parameters: {
                query: {
                    end?: number;
                    /** @description Metric to retrieve the maximum value for */
                    metric: "concurrent_sandboxes" | "sandbox_start_rate";
                    /** @description Unix timestamp for the start of the interval, in seconds, for which the metrics */
                    start?: number;
                };
                header?: never;
                path: {
                    /** @description Identifier of the team, as its UUID or its public project ID (prj_) */
                    teamID: components["parameters"]["teamID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the team metrics */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["MaxTeamMetric"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/teams/{teamID}/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get team access status
         * @description Returns whether the team is banned or blocked, and why it is blocked. A team-authenticated request may read only its own team.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /** @description Identifier of the team, as its UUID or its public project ID (prj_) */
                    teamID: components["parameters"]["teamID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the team access status */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TeamStatusResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List templates
         * @deprecated
         * @description List all templates
         */
        get: {
            parameters: {
                query?: {
                    teamID?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all templates */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Template"][];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List template builds
         * @description List all builds for a template
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of items to return per page */
                    limit?: components["parameters"]["paginationLimit"];
                    /** @description Cursor to start the list from */
                    nextToken?: components["parameters"]["paginationNextToken"];
                };
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the template with its builds */
                200: {
                    headers: {
                        "X-Next-Token": components["headers"]["XNextToken"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateWithBuilds"];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        /**
         * Delete template
         * @description Delete a template
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description The template was deleted successfully */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        /**
         * Update template
         * @deprecated
         * @description Update template
         */
        patch: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateUpdateRequest"];
                };
            };
            responses: {
                /** @description The template was updated successfully */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        trace?: never;
    };
    "/templates/{templateID}/builds/{buildID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Template build logs
         * @description Get template build logs
         */
        get: {
            parameters: {
                query?: {
                    /** @description Starting timestamp of the logs that should be returned in milliseconds */
                    cursor?: number;
                    direction?: components["schemas"]["LogsDirection"];
                    level?: components["schemas"]["LogLevel"];
                    /** @description Maximum number of logs that should be returned */
                    limit?: number;
                    /** @description Source of the logs that should be returned from */
                    source?: components["schemas"]["LogsSource"];
                };
                header?: never;
                path: {
                    buildID: components["parameters"]["buildID"];
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the template build logs */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateBuildLogsResponse"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/builds/{buildID}/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Template build status
         * @description Get template build info
         */
        get: {
            parameters: {
                query?: {
                    level?: components["schemas"]["LogLevel"];
                    /** @description Maximum number of logs that should be returned */
                    limit?: number;
                    /** @description Index of the starting build log that should be returned with the template */
                    logsOffset?: number;
                };
                header?: never;
                path: {
                    buildID: components["parameters"]["buildID"];
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the template */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateBuildInfo"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/files/{hash}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Template build file upload URL
         * @description Get an upload link for a tar file containing build layer files
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    hash: string;
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description The upload link where to upload the tar file */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateBuildFileUpload"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/tags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List template tags
         * @description List all tags for a template
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the template tags */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateTag"][];
                    };
                };
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/tags/{tag}/assignments": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List template tag assignments
         * @description Lists the ready assignments of one tag of the template, newest first, with keyset cursor pagination. Returns 404 when the template does not exist or belongs to another team.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Cursor returned by the previous list response in `assigned_at|assignment_id` format. */
                    cursor?: components["parameters"]["tagAssignmentsCursor"];
                    /** @description Maximum number of assignment rows to return per page. */
                    limit?: components["parameters"]["tagAssignmentsLimit"];
                };
                header?: never;
                path: {
                    tag: components["parameters"]["tag"];
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the tag assignments */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateTagAssignmentsResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/tags/count": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Count template tags
         * @description Returns the number of distinct tags of the template that have at least one ready build. Returns 404 when the template does not exist or belongs to another team.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the tag count */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateTagsCountResponse"];
                    };
                };
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/tags/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Check template tag
         * @description Checks whether a tag of the template has at least one ready build. Returns 404 when the template does not exist or belongs to another team.
         */
        get: {
            parameters: {
                query: {
                    /** @description Template tag name to check. */
                    tag: components["parameters"]["tagQuery"];
                };
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully checked the tag */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateTagExistsResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/tags/groups": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List template tag groups
         * @description Lists the template's tags that have at least one ready build, each with its most recent ready assignments, paginated over tags with a keyset cursor. Returns 404 when the template does not exist or belongs to another team.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of ready assignment rows to return per tag. */
                    assignmentLimit?: components["parameters"]["tagAssignmentLimit"];
                    /** @description Substring filter on tag name. Allowed characters are `a-z`, `0-9`, `.`, `_`, `-`. */
                    search?: components["parameters"]["tagGroupsSearch"];
                    /** @description Sort order for the returned tag groups. */
                    sort?: components["parameters"]["tagGroupsSort"];
                    /** @description Cursor returned by the previous list response in `{sort}|{latest_assigned_at}|{tag}` format (sort-tagged, RFC3339Nano). */
                    tagsCursor?: components["parameters"]["tagGroupsCursor"];
                    /** @description Maximum number of distinct tags to return per page. */
                    tagsLimit?: components["parameters"]["tagGroupsLimit"];
                };
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned template tag groups */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateTagGroupsResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/aliases/{alias}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Check template alias
         * @description Check if template with given alias exists
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    alias: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully queried template by alias */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateAliasResponse"];
                    };
                };
                400: components["responses"]["400"];
                403: components["responses"]["403"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/tags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Assign template tags
         * @description Assign tag(s) to a template build
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["AssignTemplateTagsRequest"];
                };
            };
            responses: {
                /** @description Tag assigned successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["AssignedTemplateTags"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        /**
         * Delete template tags
         * @description Delete multiple tags from templates
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["DeleteTemplateTagsRequest"];
                };
            };
            responses: {
                /** @description Tags deleted successfully */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/sandboxes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List sandboxes (v2)
         * @description List all sandboxes
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of items to return per page */
                    limit?: components["parameters"]["paginationLimit"];
                    /** @description Metadata query used to filter the sandboxes (e.g. "user=abc&app=prod"). Each key and values must be URL encoded. */
                    metadata?: string;
                    /** @description Cursor to start the list from */
                    nextToken?: components["parameters"]["paginationNextToken"];
                    /** @description Sort direction by sandbox start time. Defaults to desc (newest first). */
                    order?: components["schemas"]["OrderDirection"];
                    /** @description Return sandboxes started at or after this timestamp. */
                    startedAfter?: string;
                    /** @description Filter sandboxes by one or more states */
                    state?: components["schemas"]["SandboxState"][];
                    /** @description Filter sandboxes by a template ID or alias. */
                    template?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all running sandboxes */
                200: {
                    headers: {
                        "X-Next-Token": components["headers"]["XNextToken"];
                        "X-Total-Running": components["headers"]["XTotalRunning"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListedSandbox"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /**
         * Create sandbox (v2)
         * @description Create a sandbox from the template. All system communication with the sandbox is secured.
         */
        post: {
            parameters: {
                query?: never;
                header?: {
                    /**
                     * @description Optional team-scoped key for retrying sandbox creation. Use 1 to 255 lowercase ASCII
                     *     letters, digits, or hyphens (a-z, 0-9, -), such as a lowercase UUID. When idempotency is enabled,
                     *     matching retries replay the original status and body, including errors, for the retention period.
                     *     Different request parameters return 409 with error_code idempotency_request_mismatch.
                     *     An in-progress request returns 409 with error_code idempotency_in_progress; an unknown
                     *     outcome returns 422 with error_code idempotency_outcome_unknown. These retries do not execute the request again.
                     *     Retries do not extend retention. After the key expires, it can start a new creation.
                     */
                    "Idempotency-Key"?: string;
                };
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["NewSandboxV2"];
                };
            };
            responses: {
                /** @description The sandbox was created successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                /** @description Bad request */
                400: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                401: components["responses"]["401"];
                /** @description Forbidden */
                403: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description Not found */
                404: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description The Idempotency-Key conflicts with a different request (error_code idempotency_request_mismatch), or the matching original request has no recorded response yet and is within its expected response window (error_code idempotency_in_progress); this request was not executed again */
                409: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description The matching original request has no recorded response and its expected response deadline has passed or is unknown (error_code idempotency_outcome_unknown); this request was not executed again */
                422: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description Too many requests */
                429: {
                    headers: {
                        /**
                         * @description When present, the number of seconds to wait before retrying the request.
                         * @example 30
                         */
                        "Retry-After"?: number;
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description Server error */
                500: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description Service unavailable */
                503: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
                /** @description Backend timeout */
                504: {
                    headers: {
                        "Should-Retry": components["headers"]["ShouldRetry"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Error"];
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/sandboxes/{sandboxID}/connect": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Connect sandbox (v2)
         * @description Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended. The request body is optional; an omitted timeout defaults to 300 seconds.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ConnectSandboxV2"];
                };
            };
            responses: {
                /** @description The sandbox was already running */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                /** @description The sandbox was resumed successfully */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Sandbox"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
                503: components["responses"]["503"];
                504: components["responses"]["504"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/sandboxes/{sandboxID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Sandbox logs (v2)
         * @description Get sandbox logs
         */
        get: {
            parameters: {
                query?: {
                    /** @description Starting timestamp of the logs that should be returned in milliseconds */
                    cursor?: number;
                    /** @description Direction of the logs that should be returned */
                    direction?: components["schemas"]["LogsDirection"];
                    /** @description Minimum log level to return. Logs below this level are excluded */
                    level?: components["schemas"]["LogLevel"];
                    /** @description Maximum number of logs that should be returned */
                    limit?: number;
                    /** @description Case-sensitive substring match on log message content */
                    search?: string;
                };
                header?: never;
                path: {
                    sandboxID: components["parameters"]["sandboxID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned the sandbox logs */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SandboxLogsV2Response"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List templates (v2)
         * @description List all templates
         */
        get: {
            parameters: {
                query?: {
                    /** @description Maximum number of items to return per page */
                    limit?: components["parameters"]["paginationLimit"];
                    /** @description Cursor to start the list from */
                    nextToken?: components["parameters"]["paginationNextToken"];
                    teamID?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned all templates */
                200: {
                    headers: {
                        "X-Next-Token": components["headers"]["XNextToken"];
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Template"][];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/templates/{templateID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Update template (v2)
         * @description Update template
         */
        patch: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateUpdateRequest"];
                };
            };
            responses: {
                /** @description The template was updated successfully */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateUpdateResponse"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        trace?: never;
    };
    "/v2/templates/{templateID}/builds/{buildID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Start template build (v2)
         * @description Start the build
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    buildID: components["parameters"]["buildID"];
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateBuildStartV2"];
                };
            };
            responses: {
                /** @description The build has started */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v3/templates": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create template (v3)
         * @description Create a new template
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateBuildRequestV3"];
                };
            };
            responses: {
                /** @description The build was requested successfully */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateRequestResponseV3"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                403: components["responses"]["403"];
                409: components["responses"]["409"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/volumes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List team volumes
         * @description List all team volumes
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully listed all team volumes */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Volume"][];
                    };
                };
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /**
         * Create team volume
         * @description Create a new team volume
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["NewVolume"];
                };
            };
            responses: {
                /** @description Successfully created a new team volume */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["VolumeAndToken"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/volumes/{volumeID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Team volume
         * @description Get team volume info
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    volumeID: components["parameters"]["volumeID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully retrieved a team volume */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["VolumeAndToken"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        /**
         * Delete team volume
         * @description Delete a team volume
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    volumeID: components["parameters"]["volumeID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully deleted a team volume */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                429: components["responses"]["429"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        AssignedTemplateTags: {
            /**
             * Format: uuid
             * @description Identifier of the build associated with these tags
             */
            buildID: string;
            /** @description Assigned tags of the template */
            tags: string[];
        };
        AssignTemplateTagsRequest: {
            /** @description Tags to assign to the template */
            tags: string[];
            /** @description Target template in "name:tag" format */
            target: string;
        };
        AWSRegistry: {
            /** @description AWS Access Key ID for ECR authentication */
            awsAccessKeyId: string;
            /** @description AWS Region where the ECR registry is located */
            awsRegion: string;
            /** @description AWS Secret Access Key for ECR authentication */
            awsSecretAccessKey: string;
            /**
             * @description Type of registry authentication (enum property replaced by openapi-typescript)
             * @enum {string}
             */
            type: "aws";
        };
        BuildLogEntry: {
            level: components["schemas"]["LogLevel"];
            /** @description Log message content */
            message: string;
            /** @description Step in the build process related to the log entry */
            step?: string;
            /**
             * Format: date-time
             * @description Timestamp of the log entry
             */
            timestamp: string;
        };
        BuildStatusReason: {
            /**
             * @description Log entries related to the status reason
             * @default []
             */
            logEntries?: components["schemas"]["BuildLogEntry"][];
            /** @description Message with the status reason, currently reporting only for error status */
            message: string;
            /** @description Step that failed */
            step?: string;
        };
        ConnectSandbox: {
            /** @description Defaults to true. When false and the sandbox is paused, resume from disk state only: the sandbox cold-boots fresh and any memory in the snapshot is ignored, never modified or deleted. Disk state has crash-recovery semantics — writes not flushed before the pause may be lost. A no-op for snapshots that contain no memory. Rejected with an error in environments where this capability is not enabled, never silently downgraded to a memory restore. */
            memory?: boolean;
            /**
             * Format: int32
             * @description Timeout in seconds from the current time after which the sandbox should expire
             */
            timeout: number;
        };
        ConnectSandboxV2: {
            /** @description Defaults to true. When false and the sandbox is paused, resume from disk state only: the sandbox cold-boots fresh and any memory in the snapshot is ignored, never modified or deleted. Disk state has crash-recovery semantics — writes not flushed before the pause may be lost. A no-op for snapshots that contain no memory. Rejected with an error in environments where this capability is not enabled, never silently downgraded to a memory restore. */
            memory?: boolean;
            /**
             * Format: int32
             * @description Timeout in seconds from the current time after which the sandbox should expire
             * @default 300
             */
            timeout?: number;
        };
        /**
         * Format: int32
         * @description CPU cores for the sandbox
         */
        CPUCount: number;
        DeleteTemplateTagsRequest: {
            /** @description Name of the template */
            name: string;
            /** @description Tags to delete */
            tags: string[];
        };
        /**
         * Format: int32
         * @description Disk size for the sandbox in MiB
         */
        DiskSizeMB: number;
        /** @description Version of the envd running in the sandbox */
        EnvdVersion: string;
        EnvVars: {
            [key: string]: string;
        };
        Error: {
            /**
             * Format: int32
             * @description Error code
             */
            code: number;
            /** @description Machine-readable semantic error code. Not a closed set; initial values: sandbox_capacity_unavailable, sandbox_placement_timeout, sandbox_no_compatible_node, sandbox_create_failed (a node could not create the sandbox this time; retry), sandbox_create_refused (a node refused the sandbox for a reason no retry changes, such as a vcpu count out of bounds in the stored build; a server error, since no request field reaches that check), internal_server_error, secret_limit_reached, idempotency_request_mismatch, idempotency_in_progress, idempotency_outcome_unknown. */
            error_code?: string;
            /** @description Error */
            message: string;
        };
        FromImageRegistry: components["schemas"]["AWSRegistry"] | components["schemas"]["GCPRegistry"] | components["schemas"]["GeneralRegistry"];
        GCPRegistry: {
            /** @description Service Account JSON for GCP authentication */
            serviceAccountJson: string;
            /**
             * @description Type of registry authentication (enum property replaced by openapi-typescript)
             * @enum {string}
             */
            type: "gcp";
        };
        GeneralRegistry: {
            /** @description Password to use for the registry */
            password: string;
            /**
             * @description Type of registry authentication (enum property replaced by openapi-typescript)
             * @enum {string}
             */
            type: "registry";
            /** @description Username to use for the registry */
            username: string;
        };
        ListedSandbox: {
            /** @description Alias of the template */
            alias?: string;
            /**
             * @deprecated
             * @description Identifier of the client
             */
            clientID: string;
            cpuCount: components["schemas"]["CPUCount"];
            diskSizeMB: components["schemas"]["DiskSizeMB"];
            /**
             * Format: date-time
             * @description Time when the sandbox will expire
             */
            endAt: string;
            envdVersion: components["schemas"]["EnvdVersion"];
            memoryMB: components["schemas"]["MemoryMB"];
            metadata?: components["schemas"]["SandboxMetadata"];
            /** @description Identifier of the sandbox */
            sandboxID: string;
            /**
             * Format: date-time
             * @description Time when the sandbox was started
             */
            startedAt: string;
            state: components["schemas"]["SandboxState"];
            /** @description Identifier of the template from which is the sandbox created */
            templateID: string;
            volumeMounts?: components["schemas"]["SandboxVolumeMount"][];
        };
        /**
         * @description State of the sandbox
         * @enum {string}
         */
        LogLevel: "debug" | "info" | "warn" | "error";
        /**
         * @description Direction of the logs that should be returned
         * @enum {string}
         */
        LogsDirection: "forward" | "backward";
        /**
         * @description Source of the logs that should be returned
         * @enum {string}
         */
        LogsSource: "temporary" | "persistent";
        /** @description Team metric with timestamp */
        MaxTeamMetric: {
            /**
             * Format: date-time
             * @deprecated
             * @description Timestamp of the metric entry
             */
            timestamp: string;
            /**
             * Format: int64
             * @description Timestamp of the metric entry in Unix time (seconds since epoch)
             */
            timestampUnix: number;
            /** @description The maximum value of the requested metric in the given interval */
            value: number;
        };
        /** @description MCP configuration for the sandbox */
        Mcp: {
            [key: string]: unknown;
        } | null;
        /**
         * Format: int32
         * @description Memory for the sandbox in MiB
         */
        MemoryMB: number;
        /**
         * Format: int32
         * @description Requested minimum free space after the template's build steps, in MiB. Omit to use the team's default. Set to 0 to request no minimum free-disk growth. The filesystem is never shrunk, including inherited or already-larger filesystems. Growth is best effort, so filesystem metadata can leave the available space slightly below the requested minimum.
         */
        MinFreeDiskMb: number;
        NewSandbox: {
            /** @description Allow sandbox to access the internet. When set to false, it behaves the same as specifying denyOut to 0.0.0.0/0 in the network config. */
            allow_internet_access?: boolean;
            /**
             * @description Automatically pauses the sandbox after the timeout
             * @default false
             */
            autoPause?: boolean;
            /**
             * @description Controls the snapshot kind taken when the sandbox auto-pauses on timeout (only relevant when autoPause is true). When false, the auto-pause drops the in-memory state and persists only the filesystem (a filesystem-only snapshot); resuming it cold-boots (reboots) the sandbox from disk. Such a snapshot cannot be auto-resumed by traffic and must be resumed explicitly, so it cannot be combined with autoResume. Defaults to true (full memory snapshot).
             * @default true
             */
            autoPauseMemory?: boolean;
            autoResume?: components["schemas"]["SandboxAutoResumeConfig"];
            envVars?: components["schemas"]["EnvVars"];
            iam?: components["schemas"]["SandboxIam"];
            mcp?: components["schemas"]["Mcp"];
            metadata?: components["schemas"]["SandboxMetadata"];
            network?: components["schemas"]["SandboxNetworkConfig"];
            /**
             * @deprecated
             * @description Ignored. All system communication with the sandbox is always secured; the template's envd version must support secured access.
             */
            secure?: boolean;
            /** @description Identifier of the required template */
            templateID: string;
            /**
             * Format: int32
             * @description Time to live for the sandbox in seconds.
             * @default 15
             */
            timeout?: number;
            volumeMounts?: components["schemas"]["SandboxVolumeMount"][];
        };
        /** @description Sandbox creation request. All system communication with the sandbox is always secured; the template's envd version must support secured access. */
        NewSandboxV2: {
            /** @description Allow sandbox to access the internet. When set to false, it behaves the same as specifying denyOut to 0.0.0.0/0 in the network config. */
            allow_internet_access?: boolean;
            /**
             * @description Automatically pauses the sandbox after the timeout
             * @default false
             */
            autoPause?: boolean;
            /**
             * @description Controls the snapshot kind taken when the sandbox auto-pauses on timeout (only relevant when autoPause is true). When false, the auto-pause drops the in-memory state and persists only the filesystem (a filesystem-only snapshot); resuming it cold-boots (reboots) the sandbox from disk. Such a snapshot cannot be auto-resumed by traffic and must be resumed explicitly, so it cannot be combined with autoResume. Defaults to true (full memory snapshot).
             * @default true
             */
            autoPauseMemory?: boolean;
            autoResume?: components["schemas"]["SandboxAutoResumeConfig"];
            envVars?: components["schemas"]["EnvVars"];
            iam?: components["schemas"]["SandboxIam"];
            mcp?: components["schemas"]["Mcp"];
            metadata?: components["schemas"]["SandboxMetadata"];
            network?: components["schemas"]["SandboxNetworkConfig"];
            /** @description Identifier of the required template */
            templateID: string;
            /**
             * Format: int32
             * @description Time to live for the sandbox in seconds.
             * @default 300
             */
            timeout?: number;
            volumeMounts?: components["schemas"]["SandboxVolumeMount"][];
        };
        NewSecret: {
            metadata?: components["schemas"]["SecretMetadata"];
            /** @description Name of the secret, unique within the project. Names are lower-cased before storage and returned in that canonical form; the sec_ prefix is reserved for secret identifiers. */
            name: string;
            /** @description Runtime marker stored as the secret's first version. The runtime resolves it to a value at sandbox egress. */
            value: string;
        };
        NewVolume: {
            /** @description Name of the volume */
            name: string;
        };
        /**
         * @description Sort direction
         * @default desc
         * @enum {string}
         */
        OrderDirection: "asc" | "desc";
        ResumedSandbox: {
            /**
             * @deprecated
             * @description Automatically pauses the sandbox after the timeout
             */
            autoPause?: boolean;
            /** @description Defaults to true. When false, resume from disk state only: the sandbox cold-boots fresh and any memory in the snapshot is ignored, never modified or deleted. Disk state has crash-recovery semantics — writes not flushed before the pause may be lost. A no-op for snapshots that contain no memory. Rejected with an error in environments where this capability is not enabled, never silently downgraded to a memory restore. */
            memory?: boolean;
            /**
             * Format: int32
             * @description Time to live for the sandbox in seconds.
             * @default 15
             */
            timeout?: number;
        };
        Sandbox: {
            /** @description Alias of the template */
            alias?: string;
            /**
             * @deprecated
             * @description Identifier of the client
             */
            clientID: string;
            /** @description Base domain where the sandbox traffic is accessible */
            domain?: string | null;
            /** @description Access token used for envd communication */
            envdAccessToken?: string;
            envdVersion: components["schemas"]["EnvdVersion"];
            /** @description Identifier of the sandbox */
            sandboxID: string;
            /** @description Identifier of the template from which is the sandbox created */
            templateID: string;
            /** @description Token required for accessing sandbox via proxy. */
            trafficAccessToken?: string | null;
        };
        /** @description Auto-resume configuration for paused sandboxes. */
        SandboxAutoResumeConfig: {
            enabled: components["schemas"]["SandboxAutoResumeEnabled"];
        };
        /**
         * @description Auto-resume enabled flag for paused sandboxes. Default false.
         * @default false
         */
        SandboxAutoResumeEnabled: boolean;
        SandboxDetail: {
            /** @description Alias of the template */
            alias?: string;
            /** @description Whether internet access was explicitly enabled or disabled for the sandbox. Null means it was not explicitly set. */
            allowInternetAccess?: boolean | null;
            /**
             * @deprecated
             * @description Identifier of the client
             */
            clientID: string;
            cpuCount: components["schemas"]["CPUCount"];
            diskSizeMB: components["schemas"]["DiskSizeMB"];
            /** @description Base domain where the sandbox traffic is accessible */
            domain?: string | null;
            /**
             * Format: date-time
             * @description Time when the sandbox will expire
             */
            endAt: string;
            /** @description Access token used for envd communication */
            envdAccessToken?: string;
            envdVersion: components["schemas"]["EnvdVersion"];
            lifecycle?: components["schemas"]["SandboxLifecycle"];
            memoryMB: components["schemas"]["MemoryMB"];
            metadata?: components["schemas"]["SandboxMetadata"];
            network?: components["schemas"]["SandboxNetworkConfig"];
            pauseMode?: components["schemas"]["SandboxPauseMode"];
            /** @description Identifier of the sandbox */
            sandboxID: string;
            /**
             * Format: date-time
             * @description Time when the sandbox was started
             */
            startedAt: string;
            state: components["schemas"]["SandboxState"];
            /** @description Identifier of the template from which is the sandbox created */
            templateID: string;
            volumeMounts?: components["schemas"]["SandboxVolumeMount"][];
        };
        /** @description SOCKS5 proxy for sandbox egress. Outbound TCP is tunneled through the proxy after allow/deny filtering; the sandbox is unaware. Domain-matched flows use remote DNS (ATYP=domain). */
        SandboxEgressProxyConfig: {
            /** @description SOCKS5 proxy address in host:port format (e.g. "proxy.example.com:1080"). */
            address: string;
            /** @description Optional SOCKS5 password (RFC 1929), max 255 bytes. */
            password?: string;
            tls?: components["schemas"]["SandboxEgressProxyTLSConfig"];
            /** @description Optional SOCKS5 username (RFC 1929), max 255 bytes. */
            username?: string;
        } | null;
        /** @description TLS for the connection to the SOCKS5 proxy. The SOCKS5 negotiation and the tunneled traffic both run inside the TLS session, so the proxy credentials are not sent in the clear. This secures only the hop to the proxy; what the proxy does onward is its own concern. A half-close from the sandbox reaches the proxy as a TLS close_notify, not a TCP FIN, and a proxy that treats close_notify as a full close cuts the reply short. */
        SandboxEgressProxyTLSConfig: {
            /** @description One or more PEM-encoded certificates to verify the proxy against, for a proxy fronted by a private CA. These replace the system trust store, which is what is used when this is omitted. The system trust store depends on the host the orchestrator runs on, so set this to get the same verification everywhere. */
            caCert?: string;
            /** @description Connect to the proxy over TLS. When false, no other field in this object may be set. */
            enabled: boolean;
            /** @description Name to verify the proxy certificate against, and to send as SNI. Defaults to the host part of address. Set this only when the certificate does not match the address the proxy is reached at. */
            serverName?: string;
        } | null;
        SandboxesWithMetrics: {
            sandboxes: {
                [key: string]: components["schemas"]["SandboxMetric"];
            };
        };
        SandboxForkRequest: {
            /**
             * Format: int32
             * @description Number of forked sandboxes to create. All forks boot from the same snapshot, so the snapshot is captured once regardless of count. Each fork succeeds or fails independently; the outcome of each is reported in its entry of the response list.
             * @default 1
             */
            count?: number;
            /**
             * Format: int32
             * @description Time to live for the new forked sandboxes in seconds.
             * @default 15
             */
            timeout?: number;
        };
        /** @description Result of one requested fork. Exactly one of sandbox or error is set: sandbox when the fork started successfully, error when it failed to start. */
        SandboxForkResult: {
            error?: components["schemas"]["Error"];
            sandbox?: components["schemas"]["Sandbox"];
        };
        /** @description Sandbox workload identity configuration. A non-empty, valid tokens map enables workload identity for the sandbox. */
        SandboxIam: {
            tokens?: components["schemas"]["SandboxIamTokens"];
        };
        SandboxIamToken: {
            /** @description Audience of the workload token, stored exactly as provided. */
            audience: string;
            /** @description Workload token type. */
            tokenType: string;
        };
        /** @description Named workload-token definitions, keyed by a caller-chosen token name. */
        SandboxIamTokens: {
            [key: string]: components["schemas"]["SandboxIamToken"];
        };
        /** @description Sandbox lifecycle policy returned by sandbox info. */
        SandboxLifecycle: {
            /** @description Whether the sandbox can auto-resume. */
            autoResume: boolean;
            onTimeout: components["schemas"]["SandboxOnTimeout"];
        };
        /** @description Log entry with timestamp and line */
        SandboxLog: {
            /** @description Log line content */
            line: string;
            /**
             * Format: date-time
             * @description Timestamp of the log entry
             */
            timestamp: string;
        };
        SandboxLogEntry: {
            fields: {
                [key: string]: string;
            };
            level: components["schemas"]["LogLevel"];
            /** @description Log message content */
            message: string;
            /**
             * Format: date-time
             * @description Timestamp of the log entry
             */
            timestamp: string;
        };
        SandboxLogs: {
            /** @description Structured logs of the sandbox */
            logEntries: components["schemas"]["SandboxLogEntry"][];
            /** @description Logs of the sandbox */
            logs: components["schemas"]["SandboxLog"][];
        };
        SandboxLogsV2Response: {
            /**
             * @description Sandbox logs structured
             * @default []
             */
            logs: components["schemas"]["SandboxLogEntry"][];
        };
        SandboxMetadata: {
            [key: string]: string;
        };
        /** @description Metric entry with timestamp and line */
        SandboxMetric: {
            /**
             * Format: int32
             * @description Number of CPU cores
             */
            cpuCount: number;
            /**
             * Format: float
             * @description CPU usage percentage
             */
            cpuUsedPct: number;
            /**
             * Format: int64
             * @description Total disk space in bytes
             */
            diskTotal: number;
            /**
             * Format: int64
             * @description Disk used in bytes
             */
            diskUsed: number;
            /**
             * Format: int64
             * @description Cached memory (page cache) in bytes
             */
            memCache: number;
            /**
             * Format: int64
             * @description Total memory in bytes
             */
            memTotal: number;
            /**
             * Format: int64
             * @description Memory used in bytes
             */
            memUsed: number;
            /**
             * Format: date-time
             * @deprecated
             * @description Timestamp of the metric entry
             */
            timestamp: string;
            /**
             * Format: int64
             * @description Timestamp of the metric entry in Unix time (seconds since epoch)
             */
            timestampUnix: number;
        };
        SandboxNetworkConfig: {
            /** @description List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries. When allowOut contains a domain, the servers in dnsServers (8.8.8.8 by default) are also allowed. */
            allowOut?: string[];
            /**
             * @description Specify if the sandbox URLs should be accessible only with authentication.
             * @default true
             */
            allowPublicTraffic?: boolean;
            /** @description List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules. */
            denyOut?: string[];
            /** @description DNS servers the sandbox can reach when allowOut contains a domain. Each entry must be an IPv4 address, and all traffic to it is allowed. Omit it to allow the default nameserver 8.8.8.8, or pass an empty list to allow none. This does not change the sandbox's /etc/resolv.conf. */
            dnsServers?: string[];
            egressProxy?: components["schemas"]["SandboxEgressProxyConfig"];
            /** @description Sandbox ports that serve HTTPS rather than plaintext HTTP. Affects how the proxy reaches the service inside the sandbox; the public URL is HTTPS either way. Certificates are not verified, so self-signed ones work. The envd port (49983) cannot be listed. */
            httpsPorts?: number[];
            /** @description Specify host mask which will be used for all sandbox requests */
            maskRequestHost?: string;
            /** @description Per-domain transform rules applied to matching outbound HTTPS requests. Keys may be exact DNS names (for example, "api.example.com") or a leading wildcard (for example, "*.example.com"), and are normalized to lowercase on write. Wildcards match subdomains at any depth but not the apex domain; a bare "*" is invalid. Exact rules take precedence, followed by the longest matching wildcard suffix, and matching rule sets are not merged. Broad wildcards such as "*.com" are allowed and may expose transformed credentials to every matching destination the sandbox contacts. Rules do not grant network access; configure allowOut separately to permit the destination. */
            rules?: {
                [key: string]: components["schemas"]["SandboxNetworkRule"][];
            };
        };
        /** @description Transform rule applied to egress requests matching a domain pattern. */
        SandboxNetworkRule: {
            transform?: components["schemas"]["SandboxNetworkTransform"];
        };
        /** @description Transformations applied to matching egress requests before forwarding. */
        SandboxNetworkTransform: {
            /** @description HTTP headers to inject or override in matching requests. An existing header with the same name is replaced. Values are plain strings; secret resolution happens client-side before sending to the API. */
            headers?: {
                [key: string]: string;
            };
        };
        /** @description Network configuration update for a running sandbox. Replaces the current egress rules with the provided configuration. Omitting a field clears it. */
        SandboxNetworkUpdateConfig: {
            /** @description Allow sandbox to access the internet. When set to false, it behaves the same as specifying denyOut to 0.0.0.0/0 in the network config. */
            allow_internet_access?: boolean;
            /** @description List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries. When allowOut contains a domain, the servers in dnsServers (8.8.8.8 by default) are also allowed. */
            allowOut?: string[];
            /** @description List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules. */
            denyOut?: string[];
            /** @description DNS servers the sandbox can reach when allowOut contains a domain. Each entry must be an IPv4 address, and all traffic to it is allowed. Omit it to reset to the default nameserver 8.8.8.8, or pass an empty list to allow none. This does not change the sandbox's /etc/resolv.conf. */
            dnsServers?: string[];
            egressProxy?: components["schemas"]["SandboxEgressProxyConfig"];
            /** @description Per-domain transform rules applied to matching outbound HTTPS requests. Replaces all existing rules when provided. Keys may be exact DNS names or a single leading wildcard (for example, "*.example.com"), and are normalized to lowercase on write. Wildcards match subdomains at any depth but not the apex domain; a bare "*" is invalid. Exact rules take precedence, followed by the longest matching wildcard suffix, and matching rule sets are not merged. Broad wildcards such as "*.com" are allowed and may expose transformed credentials to every matching destination the sandbox contacts. Rules do not grant network access; configure allowOut separately to permit the destination. */
            rules?: {
                [key: string]: components["schemas"]["SandboxNetworkRule"][];
            };
        };
        /**
         * @description Action taken when the sandbox times out.
         * @enum {string}
         */
        SandboxOnTimeout: "kill" | "pause";
        /**
         * @description What the sandbox's latest pause saved. `full` saved the filesystem and the memory, and resuming restores the sandbox where it left off. `filesystem` saved only the filesystem, and resuming reboots the sandbox from disk. Returned for a paused sandbox once its pause has finished, and omitted while it is still pausing.
         * @enum {string}
         */
        SandboxPauseMode: "full" | "filesystem";
        SandboxPauseRequest: {
            /**
             * @description Whether to capture a full memory snapshot. When false, only the filesystem is persisted and resuming the sandbox cold-boots (reboots) it from disk, losing in-memory state, running processes, and open connections. Resume it with an explicit request (connect or resume); auto-resume, which can be triggered by arbitrary traffic, refuses such a sandbox. Defaults to true.
             * @default true
             */
            memory?: boolean;
        };
        SandboxRefreshRequest: {
            /** @description Duration for which the sandbox should be kept alive in seconds */
            duration?: number;
        };
        SandboxSnapshotRequest: {
            /** @description Whether to capture a full memory snapshot. When false, only the filesystem is persisted: the snapshot is smaller and faster to take, and sandboxes created from it cold-boot (start fresh from disk) instead of restoring memory, so they begin without the source sandbox's running processes, in-memory state, and open connections. The source sandbox keeps running in both cases. Defaults to true. */
            memory?: boolean;
            /** @description Optional name for the snapshot template. If a snapshot template with this name already exists, a new build will be assigned to the existing template instead of creating a new one. */
            name?: string;
        };
        /**
         * @description State of the sandbox
         * @enum {string}
         */
        SandboxState: "running" | "paused";
        SandboxTimeoutRequest: {
            /**
             * Format: int32
             * @description Timeout in seconds from the current time after which the sandbox should expire
             */
            timeout: number;
        };
        SandboxVolumeMount: {
            /** @description Name of the volume */
            name: string;
            /** @description Path of the volume */
            path: string;
        };
        /** @description Metadata of a secret. It never carries the secret value. */
        Secret: {
            /**
             * Format: date-time
             * @description Time when the secret was created
             */
            createdAt: string;
            /**
             * Format: int64
             * @description Version served to readers that do not name one
             */
            currentVersion: number;
            metadata: components["schemas"]["SecretMetadata"];
            /** @description Name of the secret, unique within the project */
            name: string;
            /** @description Identifier of the secret */
            secretID: string;
            /**
             * Format: date-time
             * @description Time when the secret was last updated
             */
            updatedAt: string;
        };
        /** @description Customer metadata of the secret. Always present, empty when unset. At most 32 entries; keys are limited to 128 bytes, values to 1024 bytes, and a secret's metadata to 8192 bytes in total. */
        SecretMetadata: {
            [key: string]: string;
        };
        SecretUpdate: {
            metadata?: components["schemas"]["SecretMetadata"];
            /** @description Runtime marker stored as the secret's new version. The runtime resolves it to a value at sandbox egress. */
            value: string;
        };
        SnapshotInfo: {
            /** @description Full names of the snapshot template including team namespace and tag (e.g. team-slug/my-snapshot:v2) */
            names: string[];
            /** @description Identifier of the snapshot template including the tag. Uses namespace/alias when a name was provided (e.g. team-slug/my-snapshot:default), otherwise falls back to the raw template ID (e.g. abc123:default). */
            snapshotID: string;
        };
        Team: {
            /** @description API key for the team */
            apiKey: string;
            /** @description Whether the team is the default team */
            isDefault: boolean;
            /** @description Name of the team */
            name: string;
            /** @description Identifier of the team */
            teamID: string;
        };
        /** @description The team's effective resource limits */
        TeamLimits: {
            /**
             * Format: int64
             * @description Requests per second the team may make to delete endpoints
             */
            apiTeamRpsDelete: number;
            /**
             * Format: int64
             * @description Requests per second the team may make to list endpoints
             */
            apiTeamRpsList: number;
            /**
             * Format: int64
             * @description Maximum number of sandboxes running at once
             */
            concurrentSandboxes: number;
            /**
             * Format: int64
             * @description Maximum number of template builds running at once
             */
            concurrentTemplateBuilds: number;
            /**
             * Format: int64
             * @description Free disk space a template build gets when it requests none, in MiB
             */
            defaultFreeDiskSizeMb: number;
            /**
             * Format: int64
             * @description Disk size per sandbox, in MiB
             */
            diskMb: number;
            /**
             * Format: int64
             * @description Number of days sandbox events are kept
             */
            eventsTtlDays: number;
            /**
             * Format: int64
             * @description Maximum free disk space a template build may request, in MiB
             */
            maxFreeDiskSizeMb: number;
            /**
             * Format: int64
             * @description Maximum sandbox lifetime, in hours
             */
            maxLengthHours: number;
            /**
             * Format: int64
             * @description Maximum memory per sandbox, in MiB
             */
            maxRamMb: number;
            /**
             * Format: int64
             * @description Maximum vCPUs per sandbox
             */
            maxVcpu: number;
        };
        TeamLimitsResponse: {
            limits: components["schemas"]["TeamLimits"];
        };
        /** @description Team metric with timestamp */
        TeamMetric: {
            /**
             * Format: int32
             * @description The number of concurrent sandboxes for the team
             */
            concurrentSandboxes: number;
            /**
             * Format: float
             * @description Number of sandboxes started per second
             */
            sandboxStartRate: number;
            /**
             * Format: date-time
             * @deprecated
             * @description Timestamp of the metric entry
             */
            timestamp: string;
            /**
             * Format: int64
             * @description Timestamp of the metric entry in Unix time (seconds since epoch)
             */
            timestampUnix: number;
        };
        TeamStatusResponse: {
            /** @description Why the team is blocked, if a reason was recorded */
            blockedReason: string | null;
            /** @description Whether the team is banned */
            isBanned: boolean;
            /** @description Whether the team is blocked */
            isBlocked: boolean;
        };
        TeamUser: {
            /**
             * @deprecated
             * @description Email of the user
             * @default null
             */
            email: string | null;
            /**
             * Format: uuid
             * @description Identifier of the user
             */
            id: string;
        };
        Template: {
            /**
             * @deprecated
             * @description Aliases of the template
             */
            aliases: string[];
            /**
             * Format: int32
             * @description Number of times the template was built
             */
            buildCount: number;
            /** @description Identifier of the last successful build for given template */
            buildID: string;
            buildStatus: components["schemas"]["TemplateBuildStatus"];
            cpuCount: components["schemas"]["CPUCount"];
            /**
             * Format: date-time
             * @description Time when the template was created
             */
            createdAt: string;
            createdBy: components["schemas"]["TeamUser"] | null;
            /** @description Description of the template */
            description?: string;
            diskSizeMB: components["schemas"]["DiskSizeMB"];
            envdVersion: components["schemas"]["EnvdVersion"];
            /** @description Whether the template is one of the platform's default templates. A default template owned by another team carries zero or null usage fields (`spawnCount`, `buildCount`, `lastSpawnedAt`, `createdBy`). */
            isDefault?: boolean;
            /**
             * Format: date-time
             * @description Time when the template was last used
             */
            lastSpawnedAt: string | null;
            memoryMB: components["schemas"]["MemoryMB"];
            /** @description Names of the template (namespace/alias format when namespaced) */
            names: string[];
            /** @description Whether the template is public or only accessible by the team */
            public: boolean;
            /**
             * Format: int64
             * @description Number of times the template was used
             */
            spawnCount: number;
            /** @description Identifier of the template */
            templateID: string;
            /**
             * Format: date-time
             * @description Time when the template was last updated
             */
            updatedAt: string;
        };
        TemplateAliasResponse: {
            /** @description Whether the template is public or only accessible by the team */
            public: boolean;
            /** @description Identifier of the template */
            templateID: string;
        };
        TemplateBuild: {
            /**
             * Format: uuid
             * @description Identifier of the build
             */
            buildID: string;
            cpuCount: components["schemas"]["CPUCount"];
            /**
             * Format: date-time
             * @description Time when the build was created
             */
            createdAt: string;
            diskSizeMB?: components["schemas"]["DiskSizeMB"];
            envdVersion?: components["schemas"]["EnvdVersion"];
            /**
             * Format: date-time
             * @description Time when the build was finished
             */
            finishedAt?: string;
            memoryMB: components["schemas"]["MemoryMB"];
            status: components["schemas"]["TemplateBuildStatus"];
            /**
             * Format: date-time
             * @description Time when the build was last updated
             */
            updatedAt: string;
        };
        TemplateBuildFileUpload: {
            /** @description Request headers that must be sent with the upload request */
            headers?: {
                [key: string]: string;
            };
            /** @description Whether the file is already present in the cache */
            present: boolean;
            /** @description Url where the file should be uploaded to */
            url?: string;
        };
        TemplateBuildInfo: {
            /** @description Identifier of the build */
            buildID: string;
            /**
             * @description Build logs structured
             * @default []
             */
            logEntries: components["schemas"]["BuildLogEntry"][];
            /**
             * @deprecated
             * @description Build logs (always empty since the V1 build path was removed, use logEntries)
             * @default []
             */
            logs: string[];
            reason?: components["schemas"]["BuildStatusReason"];
            status: components["schemas"]["TemplateBuildStatus"];
            /** @description Identifier of the template */
            templateID: string;
        };
        TemplateBuildLogsResponse: {
            /**
             * @description Build logs structured
             * @default []
             */
            logs: components["schemas"]["BuildLogEntry"][];
        };
        TemplateBuildRequestV3: {
            /**
             * @deprecated
             * @description Alias of the template. Deprecated, use name instead.
             */
            alias?: string;
            cpuCount?: components["schemas"]["CPUCount"];
            memoryMB?: components["schemas"]["MemoryMB"];
            minFreeDiskMb?: components["schemas"]["MinFreeDiskMb"];
            /** @description Name of the template. Can include a tag with colon separator (e.g. "my-template" or "my-template:v1"). If tag is included, it will be treated as if the tag was provided in the tags array. */
            name?: string;
            /** @description Tags to assign to the template build */
            tags?: string[];
            /**
             * @deprecated
             * @description Identifier of the team, as its UUID or its public project ID (prj_)
             */
            teamID?: string;
        };
        /** @description Exactly one of fromImage or fromTemplate must be given and non-empty. */
        TemplateBuildStartV2: {
            /**
             * @description Whether the whole build should be forced to run regardless of the cache
             * @default false
             */
            force?: boolean;
            /** @description Image to use as a base for the template build */
            fromImage?: string;
            fromImageRegistry?: components["schemas"]["FromImageRegistry"];
            /** @description Template to use as a base for the template build */
            fromTemplate?: string;
            /** @description Ready check command to execute in the template after the build */
            readyCmd?: string;
            /** @description Start command to execute in the template after the build */
            startCmd?: string;
            /**
             * @description List of steps to execute in the template build
             * @default []
             */
            steps?: components["schemas"]["TemplateStep"][];
        };
        /**
         * @description Status of the template build
         * @enum {string}
         */
        TemplateBuildStatus: "building" | "waiting" | "ready" | "error";
        TemplateRequestResponseV3: {
            /**
             * @deprecated
             * @description Aliases of the template
             */
            aliases: string[];
            /** @description Identifier of the last successful build for given template */
            buildID: string;
            /** @description Names of the template */
            names: string[];
            /** @description Whether the template is public or only accessible by the team */
            public: boolean;
            /** @description Tags assigned to the template build */
            tags: string[];
            /** @description Identifier of the template */
            templateID: string;
        };
        /** @description Step in the template build process */
        TemplateStep: {
            /**
             * @description Arguments for the step
             * @default []
             */
            args?: string[];
            /** @description Hash of the files used in the step (lowercase hex SHA-256) */
            filesHash?: string;
            /**
             * @description Whether the step should be forced to run regardless of the cache
             * @default false
             */
            force?: boolean;
            /** @description Type of the step */
            type: string;
        };
        TemplateTag: {
            /**
             * Format: uuid
             * @description Identifier of the build associated with this tag
             */
            buildID: string;
            /**
             * Format: date-time
             * @description Time when the tag was assigned
             */
            createdAt: string;
            /** @description The tag name */
            tag: string;
        };
        TemplateTagAssignment: {
            /**
             * Format: date-time
             * @description Time when the tag was assigned to the build.
             */
            assignedAt: string;
            /**
             * Format: uuid
             * @description Identifier of the tag assignment event.
             */
            assignmentId: string;
            /**
             * Format: date-time
             * @description Time when the assigned build was created.
             */
            buildCreatedAt: string;
            /**
             * Format: date-time
             * @description Time when the assigned build finished.
             */
            buildFinishedAt: string | null;
            /**
             * Format: uuid
             * @description Identifier of the assigned build.
             */
            buildId: string;
        };
        TemplateTagAssignmentsResponse: {
            /** @description Ready assignment events for the tag, sorted latest first. */
            data: components["schemas"]["TemplateTagAssignment"][];
            /** @description Cursor to pass to the next list request, or `null` if there is no next page. */
            nextCursor: string | null;
        };
        TemplateTagExistsResponse: {
            /** @description Whether the template tag has at least one ready assignment. */
            exists: boolean;
            /** @description Normalized template tag name. */
            normalizedTag: string;
        };
        TemplateTagGroup: {
            /** @description Ready assignment events for this tag, sorted latest first. */
            assignments: components["schemas"]["TemplateTagAssignment"][];
            /** @description Whether more ready assignment events exist beyond the requested assignment limit. */
            hasMore: boolean;
            /** @description Template tag name. */
            tag: string;
        };
        TemplateTagGroupsResponse: {
            /** @description Cursor to pass as `tagsCursor` for the next page, or `null` if there is no next page. */
            nextCursor: string | null;
            tags: components["schemas"]["TemplateTagGroup"][];
        };
        TemplateTagsCountResponse: {
            /**
             * Format: int64
             * @description Total distinct ready tags for the template.
             */
            total: number;
        };
        TemplateUpdateRequest: {
            /** @description Whether the template is public or only accessible by the team */
            public?: boolean;
        };
        TemplateUpdateResponse: {
            /** @description Names of the template (namespace/alias format when namespaced) */
            names: string[];
        };
        TemplateWithBuilds: components["schemas"]["Template"] & {
            /** @description List of builds for the template */
            builds: components["schemas"]["TemplateBuild"][];
        };
        Volume: {
            /** @description Name of the volume */
            name: string;
            /** @description ID of the volume */
            volumeID: string;
        };
        VolumeAndToken: {
            /**
             * @description Domain to use as the destination for volume content requests,
             *     replacing the default `api.<E2B_DOMAIN>`. Only returned when the
             *     team is connected to a custom (BYOC) cluster; absent otherwise, in
             *     which case the default domain is used.
             */
            domain?: string;
            /** @description Name of the volume */
            name: string;
            /** @description Auth token to use for interacting with volume content */
            token: string;
            /** @description ID of the volume */
            volumeID: string;
        };
    };
    responses: {
        /** @description Bad request */
        400: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Authentication error */
        401: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Forbidden */
        403: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Not found */
        404: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Conflict */
        409: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Too many requests */
        429: {
            headers: {
                /**
                 * @description When present, the number of seconds to wait before retrying the request.
                 * @example 30
                 */
                "Retry-After"?: number;
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Server error */
        500: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Backend error */
        502: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Service unavailable */
        503: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
        /** @description Backend timeout */
        504: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
    };
    parameters: {
        buildID: string;
        /** @description Maximum number of items to return per page */
        paginationLimit: number;
        /** @description Cursor to start the list from */
        paginationNextToken: string;
        sandboxID: string;
        secretID: string;
        tag: string;
        /** @description Maximum number of ready assignment rows to return per tag. */
        tagAssignmentLimit: number;
        /** @description Cursor returned by the previous list response in `assigned_at|assignment_id` format. */
        tagAssignmentsCursor: string;
        /** @description Maximum number of assignment rows to return per page. */
        tagAssignmentsLimit: number;
        /** @description Cursor returned by the previous list response in `{sort}|{latest_assigned_at}|{tag}` format (sort-tagged, RFC3339Nano). */
        tagGroupsCursor: string;
        /** @description Maximum number of distinct tags to return per page. */
        tagGroupsLimit: number;
        /** @description Substring filter on tag name. Allowed characters are `a-z`, `0-9`, `.`, `_`, `-`. */
        tagGroupsSearch: string;
        /** @description Sort order for the returned tag groups. */
        tagGroupsSort: "latest_desc" | "latest_asc" | "name_asc" | "name_desc";
        /** @description Template tag name to check. */
        tagQuery: string;
        /** @description Identifier of the team, as its UUID or its public project ID (prj_) */
        teamID: string;
        templateID: string;
        volumeID: string;
    };
    requestBodies: never;
    headers: {
        /**
         * @description Whether the condition behind this error may clear, so that retrying the request could
         *     succeed. true marks a transient failure such as missing capacity, a rate limit, or a
         *     creation still in progress: retry after Retry-After when present, otherwise with
         *     exponential backoff. false marks a failure a retry cannot fix, such as a malformed request
         *     or a configuration fault, or an outcome that is unknown, where a retry could create a
         *     second sandbox. Successful responses and errors without an explicit classification omit
         *     the header.
         */
        ShouldRetry: boolean;
        /** @description Cursor to fetch the next page of results, if more exist */
        XNextToken: string;
        /** @description Number of running sandboxes matching the filters, before pagination is applied. Only present when running sandboxes were requested. */
        XTotalRunning: number;
    };
    pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;