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

export interface paths {
    "/sandboxes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description List all running sandboxes */
        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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /** @description Create a sandbox from the template */
        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"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        /** @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"];
                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;
        /** @description Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended. */
        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"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sandboxes/{sandboxID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * @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"];
                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;
        };
        /** @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"];
                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;
        /** @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"];
                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;
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        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;
        /** @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": {
                        /** @description Duration for which the sandbox should be kept alive in seconds */
                        duration?: number;
                    };
                };
            };
            responses: {
                /** @description Successfully refreshed the sandbox */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
            };
        };
        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;
        /**
         * @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"];
                    };
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                409: components["responses"]["409"];
                500: components["responses"]["500"];
            };
        };
        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;
        /** @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": {
                        /** @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;
                    };
                };
            };
            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"];
                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;
        /** @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": {
                        /**
                         * Format: int32
                         * @description Timeout in seconds from the current time after which the sandbox should expire
                         */
                        timeout: number;
                    };
                };
            };
            responses: {
                /** @description Successfully set the sandbox timeout */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                404: components["responses"]["404"];
                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;
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/snapshots": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description List all snapshots for the team */
        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"];
                    sandboxID?: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Successfully returned snapshots */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SnapshotInfo"][];
                    };
                };
                401: components["responses"]["401"];
                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;
        };
        /** @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"];
                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;
        };
        /** @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: {
                    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"];
                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;
        };
        /** @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: {
                    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"];
                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;
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /**
         * @deprecated
         * @description Create a new template
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateBuildRequest"];
                };
            };
            responses: {
                /** @description The build was accepted */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateLegacy"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateWithBuilds"];
                    };
                };
                401: components["responses"]["401"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /**
         * @deprecated
         * @description Rebuild an template
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateBuildRequest"];
                };
            };
            responses: {
                /** @description The build was accepted */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateLegacy"];
                    };
                };
                401: components["responses"]["401"];
                500: components["responses"]["500"];
            };
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        /**
         * @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"];
                500: components["responses"]["500"];
            };
        };
        trace?: never;
    };
    "/templates/{templateID}/builds/{buildID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * @deprecated
         * @description Start the build
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    buildID: components["parameters"]["buildID"];
                    templateID: components["parameters"]["templateID"];
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description The build has started */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                401: components["responses"]["401"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/templates/{templateID}/builds/{buildID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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"];
                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;
        };
        /** @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"];
                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;
        };
        /** @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"];
                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;
        };
        /** @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"];
                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;
        };
        /** @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"];
                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;
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/sandboxes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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 Filter sandboxes by one or more states */
                    state?: components["schemas"]["SandboxState"][];
                };
                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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/v2/sandboxes/{sandboxID}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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"];
                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;
        };
        get?: never;
        put?: never;
        /**
         * @deprecated
         * @description Create a new template
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody: {
                content: {
                    "application/json": components["schemas"]["TemplateBuildRequestV2"];
                };
            };
            responses: {
                /** @description The build was requested successfully */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["TemplateLegacy"];
                    };
                };
                400: components["responses"]["400"];
                401: components["responses"]["401"];
                500: components["responses"]["500"];
            };
        };
        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;
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        trace?: never;
    };
    "/v2/templates/{templateID}/builds/{buildID}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @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;
                };
                401: components["responses"]["401"];
                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;
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/volumes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        /** @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"];
                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;
        };
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        put?: never;
        post?: never;
        /** @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"];
                500: components["responses"]["500"];
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        AdminBuildCancelResult: {
            /** @description Number of builds successfully cancelled */
            cancelledCount: number;
            /** @description Number of builds that failed to cancel */
            failedCount: number;
        };
        AdminSandboxKillResult: {
            /** @description Number of sandboxes that failed to kill */
            failedCount: number;
            /** @description Number of sandboxes successfully killed */
            killedCount: number;
        };
        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: {
            /**
             * Format: int32
             * @description Timeout in seconds from the current time after which the sandbox should expire
             */
            timeout: number;
        };
        /**
         * Format: int32
         * @description CPU cores for the sandbox
         */
        CPUCount: number;
        CreatedAccessToken: {
            /**
             * Format: date-time
             * @description Timestamp of access token creation
             */
            createdAt: string;
            /**
             * Format: uuid
             * @description Identifier of the access token
             */
            id: string;
            mask: components["schemas"]["IdentifierMaskingDetails"];
            /** @description Name of the access token */
            name: string;
            /** @description The fully created access token */
            token: string;
        };
        CreatedTeamAPIKey: {
            /**
             * Format: date-time
             * @description Timestamp of API key creation
             */
            createdAt: string;
            createdBy?: components["schemas"]["TeamUser"] | null;
            /**
             * Format: uuid
             * @description Identifier of the API key
             */
            id: string;
            /** @description Raw value of the API key */
            key: string;
            /**
             * Format: date-time
             * @description Last time this API key was used
             */
            lastUsed?: string | null;
            mask: components["schemas"]["IdentifierMaskingDetails"];
            /** @description Name of the API key */
            name: string;
        };
        DeleteTemplateTagsRequest: {
            /** @description Name of the template */
            name: string;
            /** @description Tags to delete */
            tags: string[];
        };
        DiskMetrics: {
            /** @description Device name */
            device: string;
            /** @description Filesystem type (e.g., ext4, xfs) */
            filesystemType: string;
            /** @description Mount point of the disk */
            mountPoint: string;
            /**
             * Format: uint64
             * @description Total space in bytes
             */
            totalBytes: number;
            /**
             * Format: uint64
             * @description Used space in bytes
             */
            usedBytes: number;
        };
        /**
         * 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 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;
        };
        IdentifierMaskingDetails: {
            /** @description Prefix used in masked version of the token or key */
            maskedValuePrefix: string;
            /** @description Suffix used in masked version of the token or key */
            maskedValueSuffix: string;
            /** @description Prefix that identifies the token or key type */
            prefix: string;
            /** @description Length of the token or key */
            valueLength: number;
        };
        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";
        MachineInfo: {
            /** @description CPU architecture of the node */
            cpuArchitecture: string;
            /** @description CPU family of the node */
            cpuFamily: string;
            /** @description CPU model of the node */
            cpuModel: string;
            /** @description CPU model name of the node */
            cpuModelName: string;
        };
        /** @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;
        NewAccessToken: {
            /** @description Name of the access token */
            name: string;
        };
        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"];
            mcp?: components["schemas"]["Mcp"];
            metadata?: components["schemas"]["SandboxMetadata"];
            network?: components["schemas"]["SandboxNetworkConfig"];
            /** @description Secure all system communication with sandbox */
            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"][];
        };
        NewTeamAPIKey: {
            /** @description Name of the API key */
            name: string;
        };
        NewVolume: {
            /** @description Name of the volume */
            name: string;
        };
        Node: {
            /** @description Identifier of the cluster */
            clusterID: string;
            /** @description Commit of the orchestrator */
            commit: string;
            /**
             * Format: uint64
             * @description Number of sandbox create fails
             */
            createFails: number;
            /**
             * Format: uint64
             * @description Number of sandbox create successes
             */
            createSuccesses: number;
            /** @description Identifier of the node */
            id: string;
            machineInfo: components["schemas"]["MachineInfo"];
            metrics: components["schemas"]["NodeMetrics"];
            /**
             * Format: uint32
             * @description Number of sandboxes running on the node
             */
            sandboxCount: number;
            /**
             * Format: int
             * @description Number of starting Sandboxes
             */
            sandboxStartingCount: number;
            /** @description Service instance identifier of the node */
            serviceInstanceID: string;
            status: components["schemas"]["NodeStatus"];
            /** @description Version of the orchestrator */
            version: string;
        };
        NodeDetail: {
            /** @description List of cached builds id on the node */
            cachedBuilds: string[];
            /** @description Identifier of the cluster */
            clusterID: string;
            /** @description Commit of the orchestrator */
            commit: string;
            /**
             * Format: uint64
             * @description Number of sandbox create fails
             */
            createFails: number;
            /**
             * Format: uint64
             * @description Number of sandbox create successes
             */
            createSuccesses: number;
            /** @description Identifier of the node */
            id: string;
            machineInfo: components["schemas"]["MachineInfo"];
            metrics: components["schemas"]["NodeMetrics"];
            /**
             * Format: uint32
             * @description Number of sandboxes running on the node
             */
            sandboxCount: number;
            /** @description Service instance identifier of the node */
            serviceInstanceID: string;
            status: components["schemas"]["NodeStatus"];
            /** @description Version of the orchestrator */
            version: string;
        };
        /** @description Node metrics */
        NodeMetrics: {
            /**
             * Format: uint32
             * @description Number of allocated CPU cores
             */
            allocatedCPU: number;
            /**
             * Format: uint64
             * @description Amount of allocated memory in bytes
             */
            allocatedMemoryBytes: number;
            /**
             * Format: uint32
             * @description Total number of CPU cores on the node
             */
            cpuCount: number;
            /**
             * Format: uint32
             * @description Node CPU usage percentage
             */
            cpuPercent: number;
            /** @description Detailed metrics for each disk/mount point */
            disks: components["schemas"]["DiskMetrics"][];
            /**
             * Format: uint64
             * @description Total node memory in bytes
             */
            memoryTotalBytes: number;
            /**
             * Format: uint64
             * @description Node memory used in bytes
             */
            memoryUsedBytes: number;
        };
        /**
         * @description Status of the node.
         *     - draining: the node is bound to be shut down. It will not accept new sandboxes and will stop once all existing sandboxes are done.
         *     - standby: the node is not actively used, but it can return to ready and continue serving traffic.
         *
         * @enum {string}
         */
        NodeStatus: "ready" | "draining" | "connecting" | "unhealthy" | "standby";
        NodeStatusChange: {
            /**
             * Format: uuid
             * @description Identifier of the cluster
             */
            clusterID?: string;
            status: components["schemas"]["NodeStatus"];
        };
        ResumedSandbox: {
            /**
             * @deprecated
             * @description Automatically pauses the sandbox after the timeout
             */
            autoPause?: 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"];
            /** @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"][];
        };
        SandboxesWithMetrics: {
            sandboxes: {
                [key: string]: components["schemas"]["SandboxMetric"];
            };
        };
        /** @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. */
            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 Specify host mask which will be used for all sandbox requests */
            maskRequestHost?: string;
            /** @description Per-domain transform rules applied to matching egress HTTP/HTTPS requests. Keys are domains (e.g. "api.example.com", "example.com"). A domain listed here is not automatically allowed - use allowOut to permit the traffic.
             *      */
            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. */
            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 Per-domain transform rules. Replaces all existing rules when provided. */
            rules?: {
                [key: string]: components["schemas"]["SandboxNetworkRule"][];
            };
        };
        /**
         * @description Action taken when the sandbox times out.
         * @enum {string}
         */
        SandboxOnTimeout: "kill" | "pause";
        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;
        };
        /**
         * @description State of the sandbox
         * @enum {string}
         */
        SandboxState: "running" | "paused";
        SandboxVolumeMount: {
            /** @description Name of the volume */
            name: string;
            /** @description Path of the volume */
            path: 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;
        };
        TeamAPIKey: {
            /**
             * Format: date-time
             * @description Timestamp of API key creation
             */
            createdAt: string;
            createdBy?: components["schemas"]["TeamUser"] | null;
            /**
             * Format: uuid
             * @description Identifier of the API key
             */
            id: string;
            /**
             * Format: date-time
             * @description Last time this API key was used
             */
            lastUsed?: string | null;
            mask: components["schemas"]["IdentifierMaskingDetails"];
            /** @description Name of the API key */
            name: string;
        };
        /** @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;
        };
        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;
            diskSizeMB: components["schemas"]["DiskSizeMB"];
            envdVersion: components["schemas"]["EnvdVersion"];
            /**
             * 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 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"][];
            /**
             * @description Build logs
             * @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"][];
        };
        TemplateBuildRequest: {
            /** @description Alias of the template */
            alias?: string;
            cpuCount?: components["schemas"]["CPUCount"];
            /** @description Dockerfile for the template */
            dockerfile: string;
            memoryMB?: components["schemas"]["MemoryMB"];
            /** @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 Identifier of the team */
            teamID?: string;
        };
        TemplateBuildRequestV2: {
            /** @description Alias of the template */
            alias: string;
            cpuCount?: components["schemas"]["CPUCount"];
            memoryMB?: components["schemas"]["MemoryMB"];
            /**
             * @deprecated
             * @description Identifier of the team
             */
            teamID?: string;
        };
        TemplateBuildRequestV3: {
            /**
             * @deprecated
             * @description Alias of the template. Deprecated, use name instead.
             */
            alias?: string;
            cpuCount?: components["schemas"]["CPUCount"];
            memoryMB?: components["schemas"]["MemoryMB"];
            /** @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
             */
            teamID?: string;
        };
        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";
        TemplateLegacy: {
            /** @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;
            cpuCount: components["schemas"]["CPUCount"];
            /**
             * Format: date-time
             * @description Time when the template was created
             */
            createdAt: string;
            createdBy: components["schemas"]["TeamUser"] | null;
            diskSizeMB: components["schemas"]["DiskSizeMB"];
            envdVersion: components["schemas"]["EnvdVersion"];
            /**
             * Format: date-time
             * @description Time when the template was last used
             */
            lastSpawnedAt: string | null;
            memoryMB: components["schemas"]["MemoryMB"];
            /** @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;
        };
        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 */
            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;
        };
        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: {
            /**
             * @deprecated
             * @description Aliases of the template
             */
            aliases: string[];
            /** @description List of builds for the template */
            builds: components["schemas"]["TemplateBuild"][];
            /**
             * Format: date-time
             * @description Time when the template was created
             */
            createdAt: string;
            /**
             * Format: date-time
             * @description Time when the template was last used
             */
            lastSpawnedAt: string | null;
            /** @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;
        };
        UpdateTeamAPIKey: {
            /** @description New name for the API key */
            name: string;
        };
        Volume: {
            /** @description Name of the volume */
            name: string;
            /** @description ID of the volume */
            volumeID: string;
        };
        VolumeAndToken: {
            /** @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;
        };
        VolumeToken: {
            token: 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 Server error */
        500: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Error"];
            };
        };
    };
    parameters: {
        accessTokenID: string;
        apiKeyID: string;
        buildID: string;
        nodeID: string;
        /** @description Maximum number of items to return per page */
        paginationLimit: number;
        /** @description Cursor to start the list from */
        paginationNextToken: string;
        sandboxID: string;
        snapshotID: string;
        tag: string;
        teamID: string;
        templateID: string;
        volumeID: string;
    };
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;
