@distilled.cloud/vercel 0.0.0 → 1.0.0-rc.4

package/lib/services/sandboxes.d.ts

@@ -0,0 +1,2183 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type VercelOpError, type VercelOpContext } from "../protocol.ts";
+export type { VercelOpError, VercelOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const PaymentRequired_base: S.Class<PaymentRequired, S.TaggedStruct<"PaymentRequired", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
+export declare class PaymentRequired extends /*@__PURE__*/ PaymentRequired_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+/** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode: any;
+/** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath {
+    /** Match the value exactly. Case-sensitive for paths, header values, and methods; case-insensitive for domains and header keys. */
+    exact?: string;
+    /** Match values that start with the given prefix. */
+    startsWith?: string;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem {
+    /** Matcher for the entry key (header name or query key). */
+    key?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** Matcher for the entry value. */
+    value?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem {
+    /** The domain (or pattern) of requests to add headers for. Supports wildcards like *.example.com. */
+    domain: string;
+    /** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+    headers: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem>;
+/** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList>;
+/** Network access policy for the sandbox.\n Controls which external hosts the sandbox can communicate with.\n Use \"allow-all\" mode to allow all traffic, \"deny-all\" to block all traffic or \"custom\" to provide specific rules. */
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0 {
+    /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+    mode: CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode | (string & {});
+    /** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+    allowedDomains?: CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList>;
+/** A rule applied to requests matching a domain in the network policy. Only one of `transform` or `forwardURL` can be specified per rule. */
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow = CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List | CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1>;
+export type CreateSandboxesByNameForkRequestNetworkPolicy = CreateSandboxesByNameForkRequestNetworkPolicyCase0 | CreateSandboxesByNameForkRequestNetworkPolicyCase1;
+export declare const CreateSandboxesByNameForkRequestNetworkPolicy: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicy>;
+/** Resources to define the VM */
+export interface CreateSandboxesByNameForkRequestResources {
+    /** The number of virtual CPUs to allocate to the sandbox. Must be 1, or an even number. */
+    vcpus?: number;
+    /** The amount of memory in megabytes to allocate to the sandbox. Must equal vcpus * 2048. */
+    memory?: number;
+}
+export declare const CreateSandboxesByNameForkRequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+/** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+export type CreateSandboxesByNameForkRequestPortsList = Array<number>;
+export declare const CreateSandboxesByNameForkRequestPortsList: S.Schema<CreateSandboxesByNameForkRequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesByNameForkRequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestEnvMap: S.Schema<CreateSandboxesByNameForkRequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesByNameForkRequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesByNameForkRequestMountsValueMode: any;
+export interface CreateSandboxesByNameForkRequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesByNameForkRequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesByNameForkRequestMountsValue: S.Schema<CreateSandboxesByNameForkRequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesByNameForkRequestMountsMap = {
+    [key: string]: CreateSandboxesByNameForkRequestMountsValue | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestMountsMap: S.Schema<CreateSandboxesByNameForkRequestMountsMap>;
+/** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+export type CreateSandboxesByNameForkRequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesByNameForkRequestSnapshotExpiration: S.Schema<CreateSandboxesByNameForkRequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration = unknown | number;
+export declare const CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration: S.Schema<CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. */
+export interface CreateSandboxesByNameForkRequestKeepLastSnapshots {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesByNameForkRequestKeepLastSnapshots: S.Schema<CreateSandboxesByNameForkRequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesByNameForkRequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkRequestTagsMap: S.Schema<CreateSandboxesByNameForkRequestTagsMap>;
+export interface CreateSandboxesByNameForkRequest {
+    /** Name of the source sandbox to fork. */
+    name: string;
+    /** The ID of the project the source sandbox belongs to. Required unless authenticating with an OIDC token. */
+    projectId?: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    networkPolicy?: CreateSandboxesByNameForkRequestNetworkPolicy;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkRequestResources;
+    /** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+    ports?: CreateSandboxesByNameForkRequestPortsList;
+    /** Image to use for the sandbox. */
+    image?: string;
+    /** Maximum duration in milliseconds that the sandbox can run before being automatically stopped. */
+    timeout?: number;
+    /** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+    env?: CreateSandboxesByNameForkRequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesByNameForkRequestMountsMap;
+    /** Whether the sandbox persists its state across restarts via automatic snapshots. Defaults to the source sandbox setting. */
+    persistent?: boolean;
+    /** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: CreateSandboxesByNameForkRequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. */
+    keepLastSnapshots?: CreateSandboxesByNameForkRequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesByNameForkRequestTagsMap;
+}
+export declare const CreateSandboxesByNameForkRequest: S.Schema<CreateSandboxesByNameForkRequest>;
+/** The status of the current sandbox. */
+export type NamedSandboxStatus = "running" | "stopped" | "stopping";
+export declare const NamedSandboxStatus: any;
+/** Keep-last snapshot configuration. */
+export interface NamedSandboxKeepLastSnapshots {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. */
+    expiration?: number;
+    /** Whether to immediately delete evicted snapshots. */
+    deleteEvicted: boolean;
+}
+export declare const NamedSandboxKeepLastSnapshots: S.Schema<NamedSandboxKeepLastSnapshots>;
+export type NamedSandboxNetworkPolicyMode = "allow-all" | "custom" | "default-allow" | "default-deny" | "deny-all";
+export declare const NamedSandboxNetworkPolicyMode: any;
+export type NamedSandboxNetworkPolicyAllowedDomainsList = Array<string>;
+export declare const NamedSandboxNetworkPolicyAllowedDomainsList: S.Schema<NamedSandboxNetworkPolicyAllowedDomainsList>;
+export type NamedSandboxNetworkPolicyAllowedCIDRsList = Array<string>;
+export declare const NamedSandboxNetworkPolicyAllowedCIDRsList: S.Schema<NamedSandboxNetworkPolicyAllowedCIDRsList>;
+export type NamedSandboxNetworkPolicyDeniedCIDRsList = Array<string>;
+export declare const NamedSandboxNetworkPolicyDeniedCIDRsList: S.Schema<NamedSandboxNetworkPolicyDeniedCIDRsList>;
+/** Network policy configuration. */
+export interface NamedSandboxNetworkPolicy {
+    mode: NamedSandboxNetworkPolicyMode;
+    allowedDomains?: NamedSandboxNetworkPolicyAllowedDomainsList;
+    allowedCIDRs?: NamedSandboxNetworkPolicyAllowedCIDRsList;
+    deniedCIDRs?: NamedSandboxNetworkPolicyDeniedCIDRsList;
+}
+export declare const NamedSandboxNetworkPolicy: S.Schema<NamedSandboxNetworkPolicy>;
+/** Key-value tags attached to the named sandbox. */
+export type NamedSandboxTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const NamedSandboxTagsMap: S.Schema<NamedSandboxTagsMap>;
+export type NamedSandboxMountsValueMode = "read-only" | "read-write";
+export declare const NamedSandboxMountsValueMode: any;
+/** Key-value pairs of mount path and drive. */
+export interface NamedSandboxMountsValue {
+    drive: string;
+    mode?: NamedSandboxMountsValueMode;
+}
+export declare const NamedSandboxMountsValue: S.Schema<NamedSandboxMountsValue>;
+/** Key-value pairs of mount path and drive. */
+export type NamedSandboxMountsMap = {
+    [key: string]: NamedSandboxMountsValue | undefined;
+};
+export declare const NamedSandboxMountsMap: S.Schema<NamedSandboxMountsMap>;
+/** This object contains information related to a Vercel NamedSandbox. */
+export interface NamedSandbox {
+    /** The unique identifier of the sandbox. */
+    name: string;
+    /** Current snapshot ID that the named sandbox is pointing to. */
+    currentSnapshotId?: string;
+    /** Current session ID the sandbox is pointing to. */
+    currentSessionId: string;
+    /** The status of the current sandbox. */
+    status: NamedSandboxStatus;
+    /** The time when the sandbox status was last updated, in milliseconds since the epoch. */
+    statusUpdatedAt: number;
+    /** Whether the sandbox persists its state across restarts via automatic snapshots. */
+    persistent: boolean;
+    /** The region the sandbox is configured to run in: the region set on the sandbox, otherwise the project-level default, then the platform default. Where a running session actually landed is reported by `session.region`. */
+    region?: string;
+    /** Number of virtual CPUs allocated. */
+    vcpus?: number;
+    /** Memory allocated in MB. */
+    memory?: number;
+    /** Runtime identifier. */
+    runtime?: string;
+    /** Digest-pinned reference of the container image the sandbox was created from, when it was created from an image ("{repository}@{manifestDigest}"). */
+    image?: string;
+    /** Timeout in milliseconds. */
+    timeout?: number;
+    /** Default snapshot expiration time in milliseconds. 0 means no expiration. */
+    snapshotExpiration?: number;
+    /** Keep-last snapshot configuration. */
+    keepLastSnapshots?: NamedSandboxKeepLastSnapshots;
+    /** Network policy configuration. */
+    networkPolicy?: NamedSandboxNetworkPolicy;
+    /** Cumulative egress bytes across all sandbox runs. */
+    totalEgressBytes?: number;
+    /** Cumulative ingress bytes across all sandbox runs. */
+    totalIngressBytes?: number;
+    /** Cumulative active CPU duration in milliseconds across all sandbox runs. */
+    totalActiveCpuDurationMs?: number;
+    /** Cumulative wall-clock duration in milliseconds across all sandbox runs. */
+    totalDurationMs?: number;
+    /** The working directory of the sandbox. */
+    cwd?: string;
+    /** Key-value tags attached to the named sandbox. */
+    tags?: NamedSandboxTagsMap;
+    /** Key-value pairs of mount path and drive. */
+    mounts?: NamedSandboxMountsMap;
+    /** The time when the named sandbox was created, in milliseconds since the epoch. */
+    createdAt: number;
+    /** The time when the named sandbox was last updated, in milliseconds since the epoch. */
+    updatedAt: number;
+    /** The time at which the currently running sandbox will time out, in milliseconds since the epoch. Only present while a session is running. */
+    expiresAt?: number;
+}
+export declare const NamedSandbox: S.Schema<NamedSandbox>;
+/** The status of the sandbox. */
+export type SessionStatus = "aborted" | "failed" | "pending" | "running" | "snapshotting" | "stopped" | "stopping";
+export declare const SessionStatus: any;
+/** The network policy mode. - 'allow-all': All traffic is allowed. - 'deny-all': All traffic is blocked. - 'custom': Traffic is controlled by explicit allow/deny rules. */
+export type SandboxNetworkPolicyMode = "allow-all" | "custom" | "deny-all";
+export declare const SandboxNetworkPolicyMode: any;
+/** List of domain names the sandbox is allowed to connect to. Supports wildcard patterns (e.g., "*.vercel.com" matches all subdomains). */
+export type SandboxNetworkPolicyAllowedDomainsList = Array<string>;
+export declare const SandboxNetworkPolicyAllowedDomainsList: S.Schema<SandboxNetworkPolicyAllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. */
+export type SandboxNetworkPolicyAllowedCIDRsList = Array<string>;
+export declare const SandboxNetworkPolicyAllowedCIDRsList: S.Schema<SandboxNetworkPolicyAllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type SandboxNetworkPolicyDeniedCIDRsList = Array<string>;
+export declare const SandboxNetworkPolicyDeniedCIDRsList: S.Schema<SandboxNetworkPolicyDeniedCIDRsList>;
+/** The names of HTTP headers that have value that will be injected for requests to this domain. */
+export type SandboxInjectionRuleHeaderNamesList = Array<string>;
+export declare const SandboxInjectionRuleHeaderNamesList: S.Schema<SandboxInjectionRuleHeaderNamesList>;
+/** HTTP header injection rules for outgoing requests matching specific domains. */
+export interface SandboxInjectionRule {
+    /** The domain (or pattern) that this injection rule applies to. Supports wildcards like *.vercel.com. */
+    domain: string;
+    /** The names of HTTP headers that have value that will be injected for requests to this domain. */
+    headerNames?: SandboxInjectionRuleHeaderNamesList;
+}
+export declare const SandboxInjectionRule: S.Schema<SandboxInjectionRule>;
+/** HTTP header injection rules for outgoing requests matching specific domains. */
+export type SandboxNetworkPolicyInjectionRulesList = Array<SandboxInjectionRule>;
+export declare const SandboxNetworkPolicyInjectionRulesList: S.Schema<SandboxNetworkPolicyInjectionRulesList>;
+/** The network policy applied to this sandbox, if any. */
+export interface SandboxNetworkPolicy {
+    /** The network policy mode. - 'allow-all': All traffic is allowed. - 'deny-all': All traffic is blocked. - 'custom': Traffic is controlled by explicit allow/deny rules. */
+    mode: SandboxNetworkPolicyMode;
+    /** List of domain names the sandbox is allowed to connect to. Supports wildcard patterns (e.g., "*.vercel.com" matches all subdomains). */
+    allowedDomains?: SandboxNetworkPolicyAllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. */
+    allowedCIDRs?: SandboxNetworkPolicyAllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: SandboxNetworkPolicyDeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. */
+    injectionRules?: SandboxNetworkPolicyInjectionRulesList;
+}
+export declare const SandboxNetworkPolicy: S.Schema<SandboxNetworkPolicy>;
+/** The quantity of data transfered to and from the sandbox, in bytes. This value is only available once the sandbox is stopped, and only if it stopped successfully. */
+export interface SessionNetworkTransfer {
+    ingress: number;
+    egress: number;
+}
+export declare const SessionNetworkTransfer: S.Schema<SessionNetworkTransfer>;
+/** This object contains information related to a Vercel Sandbox Session. v2 endpoints return "session" instead of "sandbox" as the response wrapper key. */
+export interface Session {
+    /** The name of the source sandbox. */
+    sourceSandboxName: string;
+    /** The unique identifier of the project associated with this session. */
+    projectId: string;
+    /** The unique identifier of the sandbox. */
+    id: string;
+    /** Memory allocated to this sandbox in MB. */
+    memory: number;
+    /** Number of vCPUs allocated to this sandbox. */
+    vcpus: number;
+    /** The region where the sandbox is hosted. */
+    region: string;
+    /** The runtime of the sandbox. */
+    runtime: string;
+    /** The maximum amount of time the sandbox will run for in milliseconds. */
+    timeout: number;
+    /** The status of the sandbox. */
+    status: SessionStatus;
+    /** The time when the sandbox was requested, in milliseconds since the epoch. */
+    requestedAt: number;
+    /** The time when the sandbox was started, in milliseconds since the epoch. */
+    startedAt?: number;
+    /** The working directory of the sandbox. */
+    cwd: string;
+    /** The time when the sandbox was requested to stop, in milliseconds since the epoch. */
+    requestedStopAt?: number;
+    /** The time when the sandbox was stopped, in milliseconds since the epoch. */
+    stoppedAt?: number;
+    /** The time when the sandbox was aborted, in milliseconds since the epoch. */
+    abortedAt?: number;
+    /** The duration of the sandbox in milliseconds. */
+    duration?: number;
+    /** The unique identifier of the snapshot associated with this sandbox, if any. */
+    sourceSnapshotId?: string;
+    /** The time when a snapshot was requested, in milliseconds since the epoch. */
+    snapshottedAt?: number;
+    /** The time when the sandbox was created, in milliseconds since the epoch. */
+    createdAt: number;
+    /** The last time the sandbox was updated, in milliseconds since the epoch. */
+    updatedAt: number;
+    networkPolicy?: SandboxNetworkPolicy;
+    /** The amount of CPU time the sandbox consumed, if available, in milliseconds. This value is only available once the sandbox is stopped, and only if it stopped successfully. */
+    activeCpuDurationMs?: number;
+    /** The quantity of data transfered to and from the sandbox, in bytes. This value is only available once the sandbox is stopped, and only if it stopped successfully. */
+    networkTransfer?: SessionNetworkTransfer;
+}
+export declare const Session: S.Schema<Session>;
+/** This object represents a public route in a Vercel Sandbox. */
+export interface SandboxPublicRoute {
+    /** A public URL to access the corresponding port in the Sandbox. */
+    url: string;
+    /** The user port number that the route is mapped to. */
+    port: number;
+    /** The subdomain assigned to this route. */
+    subdomain: string;
+    /** Whether the route is reserved by the system (e.g. for internal use). */
+    system?: boolean;
+}
+export declare const SandboxPublicRoute: S.Schema<SandboxPublicRoute>;
+export type CreateSandboxesByNameForkResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesByNameForkResponseRoutesList: S.Schema<CreateSandboxesByNameForkResponseRoutesList>;
+export interface CreateSandboxesByNameForkResponse {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesByNameForkResponseRoutesList;
+}
+export declare const CreateSandboxesByNameForkResponse: S.Schema<CreateSandboxesByNameForkResponse>;
+/** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0Mode: any;
+/** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+export type CreateSandboxesV2RequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0AllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0AllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItem {
+    /** The domain (or pattern) of requests to add headers for. Supports wildcards like *.example.com. */
+    domain: string;
+    /** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+    headers: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItem>;
+/** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesList>;
+/** Network access policy for the sandbox.\n Controls which external hosts the sandbox can communicate with.\n Use \"allow-all\" mode to allow all traffic, \"deny-all\" to block all traffic or \"custom\" to provide specific rules. */
+export interface CreateSandboxesV2RequestNetworkPolicyCase0 {
+    /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+    mode: CreateSandboxesV2RequestNetworkPolicyCase0Mode | (string & {});
+    /** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+    allowedDomains?: CreateSandboxesV2RequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesV2RequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesV2RequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueList>;
+/** A rule applied to requests matching a domain in the network policy. Only one of `transform` or `forwardURL` can be specified per rule. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1Allow = CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List | CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesV2RequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesV2RequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesV2RequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesV2RequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesV2RequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesV2RequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1>;
+export type CreateSandboxesV2RequestNetworkPolicy = CreateSandboxesV2RequestNetworkPolicyCase0 | CreateSandboxesV2RequestNetworkPolicyCase1;
+export declare const CreateSandboxesV2RequestNetworkPolicy: S.Schema<CreateSandboxesV2RequestNetworkPolicy>;
+/** The runtime environment for the sandbox. Determines the pre-installed language runtimes and tools available. */
+export type CreateSandboxesV2RequestRuntime = "node22" | "node24" | "node26" | "python3.13";
+export declare const CreateSandboxesV2RequestRuntime: any;
+/** Resources to define the VM */
+export type CreateSandboxesV2RequestResources = CreateSandboxesByNameForkRequestResources;
+export declare const CreateSandboxesV2RequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+/** Clone a Git repository into the sandbox. */
+export interface CreateSandboxesV2RequestSourceCase0 {
+    /** Indicates the source is a Git repository. */
+    type: unknown;
+    /** The URL of the Git repository to clone. */
+    url: string;
+    /** Username for Git authentication. Required together with password for private repositories. */
+    username?: string;
+    /** Password or personal access token for Git authentication. Required together with username for private repositories. */
+    password?: string | Redacted.Redacted<string>;
+    /** Create a shallow clone with history truncated to the specified number of commits. Useful for faster cloning of large repositories. */
+    depth?: number;
+    /** The specific commit SHA, branch name, or tag to checkout after cloning. */
+    revision?: string;
+}
+export declare const CreateSandboxesV2RequestSourceCase0: S.Schema<CreateSandboxesV2RequestSourceCase0>;
+/** Download and extract a gzipped tarball into the sandbox. */
+export interface CreateSandboxesV2RequestSourceCase1 {
+    /** Indicates the source is a tarball. */
+    type: unknown;
+    /** URL of a gzipped tarball (.tar.gz) to download and extract. */
+    url: string;
+}
+export declare const CreateSandboxesV2RequestSourceCase1: S.Schema<CreateSandboxesV2RequestSourceCase1>;
+/** Restore the sandbox filesystem from an existing snapshot. */
+export interface CreateSandboxesV2RequestSourceCase2 {
+    /** Indicates the source is a snapshot. */
+    type: unknown;
+    /** The unique identifier of the snapshot to restore. */
+    snapshotId: string;
+}
+export declare const CreateSandboxesV2RequestSourceCase2: S.Schema<CreateSandboxesV2RequestSourceCase2>;
+/** The source from which to initialize the sandbox filesystem. Can be a Git repository, a tarball URL, or an existing snapshot. */
+export type CreateSandboxesV2RequestSource = CreateSandboxesV2RequestSourceCase0 | CreateSandboxesV2RequestSourceCase1 | CreateSandboxesV2RequestSourceCase2;
+export declare const CreateSandboxesV2RequestSource: S.Schema<CreateSandboxesV2RequestSource>;
+/** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+export type CreateSandboxesV2RequestPortsList = Array<number>;
+export declare const CreateSandboxesV2RequestPortsList: S.Schema<CreateSandboxesV2RequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesV2RequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV2RequestEnvMap: S.Schema<CreateSandboxesV2RequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesV2RequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesV2RequestMountsValueMode: any;
+export interface CreateSandboxesV2RequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesV2RequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesV2RequestMountsValue: S.Schema<CreateSandboxesV2RequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesV2RequestMountsMap = {
+    [key: string]: CreateSandboxesV2RequestMountsValue | undefined;
+};
+export declare const CreateSandboxesV2RequestMountsMap: S.Schema<CreateSandboxesV2RequestMountsMap>;
+/** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+export type CreateSandboxesV2RequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesV2RequestSnapshotExpiration: S.Schema<CreateSandboxesV2RequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesV2RequestKeepLastSnapshotsExpiration = unknown | number;
+export declare const CreateSandboxesV2RequestKeepLastSnapshotsExpiration: S.Schema<CreateSandboxesV2RequestKeepLastSnapshotsExpiration>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. */
+export interface CreateSandboxesV2RequestKeepLastSnapshots {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesV2RequestKeepLastSnapshotsExpiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesV2RequestKeepLastSnapshots: S.Schema<CreateSandboxesV2RequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesV2RequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV2RequestTagsMap: S.Schema<CreateSandboxesV2RequestTagsMap>;
+export interface CreateSandboxesV2Request {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    networkPolicy?: CreateSandboxesV2RequestNetworkPolicy;
+    /** The runtime environment for the sandbox. Determines the pre-installed language runtimes and tools available. */
+    runtime?: CreateSandboxesV2RequestRuntime | (string & {});
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkRequestResources;
+    /** The source from which to initialize the sandbox filesystem. Can be a Git repository, a tarball URL, or an existing snapshot. */
+    source?: CreateSandboxesV2RequestSource;
+    /** The target project slug or ID in which the sandbox will be assigned to. */
+    projectId?: string;
+    /** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+    ports?: CreateSandboxesV2RequestPortsList;
+    /** Image to use for the sandbox. */
+    image?: string;
+    /** Maximum duration in milliseconds that the sandbox can run before being automatically stopped. */
+    timeout?: number;
+    /** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+    env?: CreateSandboxesV2RequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesV2RequestMountsMap;
+    /** Name for the sandbox. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name?: string;
+    /** Whether the sandbox persists its state across restarts via automatic snapshots. Defaults to true. */
+    persistent?: boolean;
+    /** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: CreateSandboxesV2RequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. */
+    keepLastSnapshots?: CreateSandboxesV2RequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesV2RequestTagsMap;
+}
+export declare const CreateSandboxesV2Request: S.Schema<CreateSandboxesV2Request>;
+export type CreateSandboxesV2ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesV2ResponseRoutesList: S.Schema<CreateSandboxesV2ResponseRoutesList>;
+export interface CreateSandboxesV2Response {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesV2ResponseRoutesList;
+}
+export declare const CreateSandboxesV2Response: S.Schema<CreateSandboxesV2Response>;
+/** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0Mode: any;
+/** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+export type CreateSandboxesV3RequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0AllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0AllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItem {
+    /** The domain (or pattern) of requests to add headers for. Supports wildcards like *.example.com. */
+    domain: string;
+    /** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+    headers: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItem>;
+/** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesList>;
+/** Network access policy for the sandbox.\n Controls which external hosts the sandbox can communicate with.\n Use \"allow-all\" mode to allow all traffic, \"deny-all\" to block all traffic or \"custom\" to provide specific rules. */
+export interface CreateSandboxesV3RequestNetworkPolicyCase0 {
+    /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+    mode: CreateSandboxesV3RequestNetworkPolicyCase0Mode | (string & {});
+    /** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+    allowedDomains?: CreateSandboxesV3RequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesV3RequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesV3RequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueList>;
+/** A rule applied to requests matching a domain in the network policy. Only one of `transform` or `forwardURL` can be specified per rule. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1Allow = CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List | CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesV3RequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesV3RequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesV3RequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesV3RequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesV3RequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesV3RequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1>;
+export type CreateSandboxesV3RequestNetworkPolicy = CreateSandboxesV3RequestNetworkPolicyCase0 | CreateSandboxesV3RequestNetworkPolicyCase1;
+export declare const CreateSandboxesV3RequestNetworkPolicy: S.Schema<CreateSandboxesV3RequestNetworkPolicy>;
+/** Resources to define the VM */
+export type CreateSandboxesV3RequestResources = CreateSandboxesByNameForkRequestResources;
+export declare const CreateSandboxesV3RequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+/** Clone a Git repository into the sandbox. */
+export type CreateSandboxesV3RequestSourceCase0 = CreateSandboxesV2RequestSourceCase0;
+export declare const CreateSandboxesV3RequestSourceCase0: S.Schema<CreateSandboxesV2RequestSourceCase0>;
+/** Download and extract a gzipped tarball into the sandbox. */
+export type CreateSandboxesV3RequestSourceCase1 = CreateSandboxesV2RequestSourceCase1;
+export declare const CreateSandboxesV3RequestSourceCase1: S.Schema<CreateSandboxesV2RequestSourceCase1>;
+/** Restore the sandbox filesystem from an existing snapshot. */
+export type CreateSandboxesV3RequestSourceCase2 = CreateSandboxesV2RequestSourceCase2;
+export declare const CreateSandboxesV3RequestSourceCase2: S.Schema<CreateSandboxesV2RequestSourceCase2>;
+/** The source from which to initialize the sandbox filesystem. Can be a Git repository, a tarball URL, or an existing snapshot. */
+export type CreateSandboxesV3RequestSource = CreateSandboxesV2RequestSourceCase0 | CreateSandboxesV2RequestSourceCase1 | CreateSandboxesV2RequestSourceCase2;
+export declare const CreateSandboxesV3RequestSource: S.Schema<CreateSandboxesV3RequestSource>;
+/** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+export type CreateSandboxesV3RequestPortsList = Array<number>;
+export declare const CreateSandboxesV3RequestPortsList: S.Schema<CreateSandboxesV3RequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesV3RequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV3RequestEnvMap: S.Schema<CreateSandboxesV3RequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesV3RequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesV3RequestMountsValueMode: any;
+export interface CreateSandboxesV3RequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesV3RequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesV3RequestMountsValue: S.Schema<CreateSandboxesV3RequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesV3RequestMountsMap = {
+    [key: string]: CreateSandboxesV3RequestMountsValue | undefined;
+};
+export declare const CreateSandboxesV3RequestMountsMap: S.Schema<CreateSandboxesV3RequestMountsMap>;
+/** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+export type CreateSandboxesV3RequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesV3RequestSnapshotExpiration: S.Schema<CreateSandboxesV3RequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesV3RequestKeepLastSnapshotsExpiration = unknown | number;
+export declare const CreateSandboxesV3RequestKeepLastSnapshotsExpiration: S.Schema<CreateSandboxesV3RequestKeepLastSnapshotsExpiration>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. */
+export interface CreateSandboxesV3RequestKeepLastSnapshots {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesV3RequestKeepLastSnapshotsExpiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesV3RequestKeepLastSnapshots: S.Schema<CreateSandboxesV3RequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesV3RequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV3RequestTagsMap: S.Schema<CreateSandboxesV3RequestTagsMap>;
+export interface CreateSandboxesV3Request {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    networkPolicy?: CreateSandboxesV3RequestNetworkPolicy;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkRequestResources;
+    /** The source from which to initialize the sandbox filesystem. Can be a Git repository, a tarball URL, or an existing snapshot. */
+    source?: CreateSandboxesV3RequestSource;
+    /** The target project slug or ID in which the sandbox will be assigned to. */
+    projectId?: string;
+    /** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+    ports?: CreateSandboxesV3RequestPortsList;
+    /** Image to use for the sandbox. */
+    image?: string;
+    /** Maximum duration in milliseconds that the sandbox can run before being automatically stopped. */
+    timeout?: number;
+    /** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+    env?: CreateSandboxesV3RequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesV3RequestMountsMap;
+    /** Name for the sandbox. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name?: string;
+    /** Whether the sandbox persists its state across restarts via automatic snapshots. Defaults to true. */
+    persistent?: boolean;
+    /** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: CreateSandboxesV3RequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. */
+    keepLastSnapshots?: CreateSandboxesV3RequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesV3RequestTagsMap;
+}
+export declare const CreateSandboxesV3Request: S.Schema<CreateSandboxesV3Request>;
+export type CreateSandboxesV3ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesV3ResponseRoutesList: S.Schema<CreateSandboxesV3ResponseRoutesList>;
+export interface CreateSandboxesV3Response {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesV3ResponseRoutesList;
+}
+export declare const CreateSandboxesV3Response: S.Schema<CreateSandboxesV3Response>;
+export interface CreateSessionDirectoryRequest {
+    /** The unique identifier of the session to create the directory in. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The base directory for resolving relative paths. If not specified, paths are resolved from the sandbox home directory. */
+    cwd?: string;
+    /** The path of the directory to create. Can be absolute or relative to the working directory. */
+    path: string;
+    /** If true, creates parent directories as needed (like `mkdir -p`). If false, fails if parent directories do not exist. */
+    recursive?: boolean;
+}
+export declare const CreateSessionDirectoryRequest: S.Schema<CreateSessionDirectoryRequest>;
+export type CreateSessionDirectoryResponse = unknown;
+export declare const CreateSessionDirectoryResponse: S.Schema<CreateSessionDirectoryResponse>;
+/** The number of milliseconds after which the snapshot will expire and be deleted. Use 0 for no expiration. */
+export type CreateSessionSnapshotRequestExpiration = unknown | number;
+export declare const CreateSessionSnapshotRequestExpiration: S.Schema<CreateSessionSnapshotRequestExpiration>;
+export interface CreateSessionSnapshotRequest {
+    /** The unique identifier of the session to snapshot. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The number of milliseconds after which the snapshot will expire and be deleted. Use 0 for no expiration. */
+    expiration?: CreateSessionSnapshotRequestExpiration;
+}
+export declare const CreateSessionSnapshotRequest: S.Schema<CreateSessionSnapshotRequest>;
+/** The status of the snapshot. */
+export type SnapshotStatus = "created" | "deleted" | "failed";
+export declare const SnapshotStatus: any;
+/** The method used to create the snapshot. */
+export type SnapshotCreationMethod = "automatic" | "manual";
+export declare const SnapshotCreationMethod: any;
+/** This object contains information related to a Snapshot of a Vercel Sandbox session (v2 API). */
+export interface Snapshot {
+    /** The unique identifier of the snapshot. */
+    id: string;
+    /** The unique identifier of the session from which the snapshot was created. */
+    sourceSessionId: string;
+    /** The region where the snapshot is stored. */
+    region?: string;
+    /** The status of the snapshot. */
+    status: SnapshotStatus;
+    /** The size of the snapshot in bytes. */
+    sizeBytes: number;
+    /** The time when the snapshot will expire, in milliseconds since the epoch. If not set, the snapshot does not have any expiration. */
+    expiresAt?: number;
+    /** The time when the snapshot was created, in milliseconds since the epoch. */
+    createdAt: number;
+    /** The last time the snapshot was updated, in milliseconds since the epoch. */
+    updatedAt: number;
+    /** The last time the snapshot was used (e.g. to resume or create a sandbox), in milliseconds since the epoch. Falls back to `createdAt` for older snapshots that predate this field. */
+    lastUsedAt: number;
+    /** The method used to create the snapshot. */
+    creationMethod?: SnapshotCreationMethod;
+    /** The unique identifier of the parent snapshot, if this snapshot was created from another snapshot. */
+    parentId?: string;
+}
+export declare const Snapshot: S.Schema<Snapshot>;
+export interface CreateSessionSnapshotResponse {
+    snapshot: Snapshot;
+    session: Session;
+}
+export declare const CreateSessionSnapshotResponse: S.Schema<CreateSessionSnapshotResponse>;
+export interface DeleteDriveRequest {
+    /** Name for the drive. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name: string;
+    /** The project ID or name associated with the drive. Required unless using a Vercel OIDC token scoped to a project. */
+    projectId?: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteDriveRequest: S.Schema<DeleteDriveRequest>;
+/** This object contains information related to a Vercel Sandbox Drive. */
+export interface Drive {
+    /** The unique drive name within the project. */
+    name: string;
+    /** The project that owns the drive. */
+    projectId: string;
+    /** The maximum drive size in bytes. */
+    maxSizeBytes: number;
+    /** The region where the drive is stored. */
+    region: string;
+    /** Current session ID the drive is attached to, if any. */
+    currentSessionId?: string;
+    /** Current sandbox name the drive is attached to, if any. */
+    currentSandboxName?: string;
+    /** The time when the drive was created, in milliseconds since the epoch. */
+    createdAt: number;
+    /** The last time the drive was updated, in milliseconds since the epoch. */
+    updatedAt: number;
+}
+export declare const Drive: S.Schema<Drive>;
+export interface DeleteDriveResponse {
+    drive: Drive;
+}
+export declare const DeleteDriveResponse: S.Schema<DeleteDriveResponse>;
+export interface DeleteSandboxRequest {
+    /** The sandbox name to delete. */
+    name: string;
+    /** The project ID that owns the named sandbox. When provided, takes precedence over OIDC project context. */
+    projectId?: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteSandboxRequest: S.Schema<DeleteSandboxRequest>;
+export interface DeleteSandboxResponse {
+    sandbox: NamedSandbox;
+}
+export declare const DeleteSandboxResponse: S.Schema<DeleteSandboxResponse>;
+export interface DeleteSessionSnapshotRequest {
+    /** The unique identifier of the snapshot to delete. */
+    snapshotId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteSessionSnapshotRequest: S.Schema<DeleteSessionSnapshotRequest>;
+export interface DeleteSessionSnapshotResponse {
+    snapshot: Snapshot;
+}
+export declare const DeleteSessionSnapshotResponse: S.Schema<DeleteSessionSnapshotResponse>;
+export interface ExtendSessionTimeoutRequest {
+    /** The unique identifier of the session to extend the timeout for. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The amount of time in milliseconds to add to the current timeout. Must be at least 1000ms (1 second). */
+    duration: number;
+}
+export declare const ExtendSessionTimeoutRequest: S.Schema<ExtendSessionTimeoutRequest>;
+export interface ExtendSessionTimeoutResponse {
+    session: Session;
+}
+export declare const ExtendSessionTimeoutResponse: S.Schema<ExtendSessionTimeoutResponse>;
+export interface GetNamedSandboxRequest {
+    /** Name for the sandbox. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name: string;
+    /** The project ID or name (required when not using OIDC token). */
+    projectId?: string;
+    /** Whether to automatically resume a stopped named sandbox by creating a new instance from its snapshot. Defaults to false. */
+    resume?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetNamedSandboxRequest: S.Schema<GetNamedSandboxRequest>;
+export type GetNamedSandboxResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const GetNamedSandboxResponseRoutesList: S.Schema<GetNamedSandboxResponseRoutesList>;
+export interface GetNamedSandboxResponse {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: GetNamedSandboxResponseRoutesList;
+    resumed: boolean;
+}
+export declare const GetNamedSandboxResponse: S.Schema<GetNamedSandboxResponse>;
+/** Region where the drive is stored. Defaults to iad1. */
+export type GetOrCreateDriveRequestRegion = "iad1" | "sfo1" | "cle1";
+export declare const GetOrCreateDriveRequestRegion: any;
+export interface GetOrCreateDriveRequest {
+    /** Name for the drive. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The project ID or name to associate the drive with. Required unless using a Vercel OIDC token scoped to a project. */
+    projectId?: string;
+    /** Maximum drive size in bytes. Defaults to 100 GiB when omitted. */
+    maxSizeBytes?: number;
+    /** Region where the drive is stored. Defaults to iad1. */
+    region?: GetOrCreateDriveRequestRegion | (string & {});
+}
+export declare const GetOrCreateDriveRequest: S.Schema<GetOrCreateDriveRequest>;
+export interface GetOrCreateDriveResponse {
+    drive: Drive;
+}
+export declare const GetOrCreateDriveResponse: S.Schema<GetOrCreateDriveResponse>;
+export interface GetSessionRequest {
+    /** The unique identifier of the session to retrieve. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetSessionRequest: S.Schema<GetSessionRequest>;
+export type GetSessionResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const GetSessionResponseRoutesList: S.Schema<GetSessionResponseRoutesList>;
+export interface GetSessionResponse {
+    session: Session;
+    routes: GetSessionResponseRoutesList;
+}
+export declare const GetSessionResponse: S.Schema<GetSessionResponse>;
+/** If set to "true", the request will block until the command finishes execution. Useful for synchronously waiting for command completion. */
+export type GetSessionCommandRequestWait = "true" | "false";
+export declare const GetSessionCommandRequestWait: any;
+export interface GetSessionCommandRequest {
+    /** The unique identifier of the session containing the command. */
+    sessionId: string;
+    /** The unique identifier of the command to retrieve. */
+    cmdId: string;
+    /** If set to "true", the request will block until the command finishes execution. Useful for synchronously waiting for command completion. */
+    wait?: GetSessionCommandRequestWait | (string & {});
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetSessionCommandRequest: S.Schema<GetSessionCommandRequest>;
+/** The arguments of the command. */
+export type SessionCommandArgsList = Array<string>;
+export declare const SessionCommandArgsList: S.Schema<SessionCommandArgsList>;
+/** This object represents a command run in a Vercel Sandbox session (v2 API). */
+export interface SessionCommand {
+    /** The ID of the command. */
+    id: string;
+    /** The name of the command. */
+    name: string;
+    /** The arguments of the command. */
+    args: SessionCommandArgsList;
+    /** The current working directory of the command. */
+    cwd: string;
+    /** The ID of the session associated with the command. */
+    sessionId: string;
+    /** If the command did finish, the exit code. */
+    exitCode: number | null;
+    /** When the command was started, in milliseconds since the epoch. */
+    startedAt: number;
+    /** Duration of the command execution in milliseconds. */
+    durationMs?: number;
+}
+export declare const SessionCommand: S.Schema<SessionCommand>;
+export interface GetSessionCommandResponse {
+    command: SessionCommand;
+}
+export declare const GetSessionCommandResponse: S.Schema<GetSessionCommandResponse>;
+export interface GetSessionCommandLogsRequest {
+    /** The unique identifier of the session containing the command. */
+    sessionId: string;
+    /** The unique identifier of the command to stream logs for. */
+    cmdId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetSessionCommandLogsRequest: S.Schema<GetSessionCommandLogsRequest>;
+export interface GetSessionCommandLogsResponse {
+}
+export declare const GetSessionCommandLogsResponse: S.Schema<GetSessionCommandLogsResponse>;
+export interface GetSessionSnapshotRequest {
+    /** The unique identifier of the snapshot to retrieve. */
+    snapshotId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetSessionSnapshotRequest: S.Schema<GetSessionSnapshotRequest>;
+export interface GetSessionSnapshotResponse {
+    snapshot: Snapshot;
+}
+export declare const GetSessionSnapshotResponse: S.Schema<GetSessionSnapshotResponse>;
+export interface KillSessionCommandRequest {
+    /** The unique identifier of the session containing the command. */
+    sessionId: string;
+    /** The unique identifier of the command to terminate. */
+    cmdId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The POSIX signal number to send to the process. Common values: 15 (SIGTERM) for graceful termination, 9 (SIGKILL) for forced termination. */
+    signal: number;
+}
+export declare const KillSessionCommandRequest: S.Schema<KillSessionCommandRequest>;
+export interface KillSessionCommandResponse {
+    command: SessionCommand;
+}
+export declare const KillSessionCommandResponse: S.Schema<KillSessionCommandResponse>;
+/** Field to sort drives by. */
+export type ListDrivesRequestSortBy = "createdAt" | "updatedAt" | "name";
+export declare const ListDrivesRequestSortBy: any;
+/** Sort direction for results. */
+export type ListDrivesRequestSortOrder = "asc" | "desc";
+export declare const ListDrivesRequestSortOrder: any;
+export interface ListDrivesRequest {
+    /** The project ID or name associated with the drives. Required unless using a Vercel OIDC token scoped to a project. */
+    projectId?: string;
+    /** Maximum number of drives to return in the response. Used for pagination. */
+    limit?: number;
+    /** Opaque pagination cursor from a previous response. */
+    cursor?: string;
+    /** Field to sort drives by. */
+    sortBy?: ListDrivesRequestSortBy | (string & {});
+    /** Filter drives whose name starts with this prefix. Only valid when sortBy=name. */
+    namePrefix?: string;
+    /** Sort direction for results. */
+    sortOrder?: ListDrivesRequestSortOrder | (string & {});
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListDrivesRequest: S.Schema<ListDrivesRequest>;
+export type ListDrivesResponseDrivesList = Array<Drive>;
+export declare const ListDrivesResponseDrivesList: S.Schema<ListDrivesResponseDrivesList>;
+export interface ListDrivesResponsePagination {
+    count: number;
+    next: string | null;
+}
+export declare const ListDrivesResponsePagination: S.Schema<ListDrivesResponsePagination>;
+export interface ListDrivesResponse {
+    drives: ListDrivesResponseDrivesList;
+    pagination: ListDrivesResponsePagination;
+}
+export declare const ListDrivesResponse: S.Schema<ListDrivesResponse>;
+/** Field to sort by. */
+export type ListSandboxesRequestSortBy = "createdAt" | "name" | "statusUpdatedAt" | "currentSnapshotId";
+export declare const ListSandboxesRequestSortBy: any;
+/** Sort direction. Defaults to desc. */
+export type ListSandboxesRequestSortOrder = "asc" | "desc";
+export declare const ListSandboxesRequestSortOrder: any;
+/** Filter named sandboxes by status. Only valid when sortBy is createdAt. */
+export type ListSandboxesRequestStatus = "running" | "stopping" | "stopped";
+export declare const ListSandboxesRequestStatus: any;
+export type ListSandboxesRequestTagsCase1List = Array<string>;
+export declare const ListSandboxesRequestTagsCase1List: S.Schema<ListSandboxesRequestTagsCase1List>;
+/** Filter sandboxes by tag. Format: \"key:value\". Only one tag filter is supported at a time. */
+export type ListSandboxesRequestTags = string | ListSandboxesRequestTagsCase1List;
+export declare const ListSandboxesRequestTags: S.Schema<ListSandboxesRequestTags>;
+export interface ListSandboxesRequest {
+    /** The unique identifier or name of the project to list named sandboxes for. */
+    project?: string;
+    /** Maximum number of named sandboxes to return in the response. Used for pagination. */
+    limit?: number;
+    /** Field to sort by. */
+    sortBy?: ListSandboxesRequestSortBy | (string & {});
+    /** Filter named sandboxes whose name starts with this prefix. Only valid when sortBy=name. */
+    namePrefix?: string;
+    /** Opaque pagination cursor from a previous response. */
+    cursor?: string;
+    /** Sort direction. Defaults to desc. */
+    sortOrder?: ListSandboxesRequestSortOrder | (string & {});
+    /** Filter named sandboxes by status. Only valid when sortBy is createdAt. */
+    status?: ListSandboxesRequestStatus | (string & {});
+    /** Filter sandboxes by tag. Format: \"key:value\". Only one tag filter is supported at a time. */
+    tags?: ListSandboxesRequestTags;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListSandboxesRequest: S.Schema<ListSandboxesRequest>;
+export type ListSandboxesResponseSandboxesList = Array<NamedSandbox>;
+export declare const ListSandboxesResponseSandboxesList: S.Schema<ListSandboxesResponseSandboxesList>;
+export type ListSandboxesResponsePagination = ListDrivesResponsePagination;
+export declare const ListSandboxesResponsePagination: S.Schema<ListDrivesResponsePagination>;
+export interface ListSandboxesResponse {
+    sandboxes: ListSandboxesResponseSandboxesList;
+    pagination: ListDrivesResponsePagination;
+}
+export declare const ListSandboxesResponse: S.Schema<ListSandboxesResponse>;
+export interface ListSessionCommandsRequest {
+    /** The unique identifier of the session to list commands for. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListSessionCommandsRequest: S.Schema<ListSessionCommandsRequest>;
+export type ListSessionCommandsResponseCommandsList = Array<SessionCommand>;
+export declare const ListSessionCommandsResponseCommandsList: S.Schema<ListSessionCommandsResponseCommandsList>;
+export interface ListSessionCommandsResponse {
+    commands: ListSessionCommandsResponseCommandsList;
+}
+export declare const ListSessionCommandsResponse: S.Schema<ListSessionCommandsResponse>;
+/** Sort direction for results by creation time. */
+export type ListSessionsRequestSortOrder = "asc" | "desc";
+export declare const ListSessionsRequestSortOrder: any;
+export interface ListSessionsRequest {
+    /** The unique identifier or name of the project to list sessions for. */
+    project?: string;
+    /** Filter sessions by sandbox name. Only sessions belonging to the specified sandbox are returned. */
+    name?: string;
+    /** Maximum number of sessions to return in the response. Used for pagination. */
+    limit?: number;
+    /** Opaque pagination cursor from a previous response. */
+    cursor?: string;
+    /** Sort direction for results by creation time. */
+    sortOrder?: ListSessionsRequestSortOrder | (string & {});
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListSessionsRequest: S.Schema<ListSessionsRequest>;
+export type ListSessionsResponseBodyCase1SessionsList = Array<Session>;
+export declare const ListSessionsResponseBodyCase1SessionsList: S.Schema<ListSessionsResponseBodyCase1SessionsList>;
+export type ListSessionsResponseBodyCase1Pagination = ListDrivesResponsePagination;
+export declare const ListSessionsResponseBodyCase1Pagination: S.Schema<ListDrivesResponsePagination>;
+export interface ListSessionsResponseBodyCase1 {
+    sessions: ListSessionsResponseBodyCase1SessionsList;
+    pagination: ListDrivesResponsePagination;
+}
+export declare const ListSessionsResponseBodyCase1: S.Schema<ListSessionsResponseBodyCase1>;
+export type ListSessionsResponseBody = unknown | ListSessionsResponseBodyCase1;
+export declare const ListSessionsResponseBody: S.Schema<ListSessionsResponseBody>;
+export type ListSessionsResponse = ListSessionsResponseBody;
+export declare const ListSessionsResponse: S.Schema<ListSessionsResponse>;
+/** Sort direction for results by creation time. */
+export type ListSessionSnapshotsRequestSortOrder = "asc" | "desc";
+export declare const ListSessionSnapshotsRequestSortOrder: any;
+export interface ListSessionSnapshotsRequest {
+    /** The unique identifier or name of the project to list snapshots for. */
+    project?: string;
+    /** Name for the sandbox. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
+    name?: string;
+    /** Maximum number of snapshots to return in the response. Used for pagination. */
+    limit?: number;
+    /** Opaque pagination cursor from a previous response. */
+    cursor?: string;
+    /** Sort direction for results by creation time. */
+    sortOrder?: ListSessionSnapshotsRequestSortOrder | (string & {});
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const ListSessionSnapshotsRequest: S.Schema<ListSessionSnapshotsRequest>;
+export type ListSessionSnapshotsResponseBodyCase1SnapshotsList = Array<Snapshot>;
+export declare const ListSessionSnapshotsResponseBodyCase1SnapshotsList: S.Schema<ListSessionSnapshotsResponseBodyCase1SnapshotsList>;
+export type ListSessionSnapshotsResponseBodyCase1Pagination = ListDrivesResponsePagination;
+export declare const ListSessionSnapshotsResponseBodyCase1Pagination: S.Schema<ListDrivesResponsePagination>;
+export interface ListSessionSnapshotsResponseBodyCase1 {
+    snapshots: ListSessionSnapshotsResponseBodyCase1SnapshotsList;
+    pagination: ListDrivesResponsePagination;
+}
+export declare const ListSessionSnapshotsResponseBodyCase1: S.Schema<ListSessionSnapshotsResponseBodyCase1>;
+export type ListSessionSnapshotsResponseBody = unknown | ListSessionSnapshotsResponseBodyCase1;
+export declare const ListSessionSnapshotsResponseBody: S.Schema<ListSessionSnapshotsResponseBody>;
+export type ListSessionSnapshotsResponse = ListSessionSnapshotsResponseBody;
+export declare const ListSessionSnapshotsResponse: S.Schema<ListSessionSnapshotsResponse>;
+export interface ReadSessionFileRequest {
+    /** The unique identifier of the session to read the file from. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The base directory for resolving relative paths. If not specified, paths are resolved from the sandbox home directory. */
+    cwd?: string;
+    /** The path of the file to read. Can be absolute or relative to the working directory. */
+    path: string;
+}
+export declare const ReadSessionFileRequest: S.Schema<ReadSessionFileRequest>;
+export interface ReadSessionFileResponse {
+}
+export declare const ReadSessionFileResponse: S.Schema<ReadSessionFileResponse>;
+/** Arguments to pass to the command. Each argument should be a separate array element. */
+export type RunSessionCommandRequestArgsList = Array<string>;
+export declare const RunSessionCommandRequestArgsList: S.Schema<RunSessionCommandRequestArgsList>;
+/** Additional environment variables to set for this command. These are merged with the sandbox environment. */
+export type RunSessionCommandRequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const RunSessionCommandRequestEnvMap: S.Schema<RunSessionCommandRequestEnvMap>;
+export interface RunSessionCommandRequest {
+    /** The unique identifier of the session in which to execute the command. */
+    sessionId: string;
+    /** The unique identifier of the command to stream logs for. */
+    cmdId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The executable or shell command to run. This is the program name without arguments. */
+    command: string;
+    /** Arguments to pass to the command. Each argument should be a separate array element. */
+    args?: RunSessionCommandRequestArgsList;
+    /** The working directory in which to execute the command. Defaults to the sandbox home directory if not specified. */
+    cwd?: string;
+    /** Additional environment variables to set for this command. These are merged with the sandbox environment. */
+    env?: RunSessionCommandRequestEnvMap;
+    /** Execute the command with root (superuser) privileges. */
+    sudo?: boolean;
+    /** If true, returns an ND-JSON stream that emits the command status when started and again when finished. Useful for synchronously waiting for command completion. */
+    wait?: boolean;
+    /** If true, stream the logs of the command execution in real-time via ND-JSON. This is only applicable if `wait` is also true. */
+    logs?: boolean;
+    /** Maximum duration in milliseconds the command may run before it is killed with SIGKILL. Enforced at exec time, independently of `wait`. */
+    timeout?: number;
+}
+export declare const RunSessionCommandRequest: S.Schema<RunSessionCommandRequest>;
+export interface RunSessionCommandResponse {
+    command: SessionCommand;
+}
+export declare const RunSessionCommandResponse: S.Schema<RunSessionCommandResponse>;
+export interface StopSessionRequest {
+    /** The unique identifier of the session to stop. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const StopSessionRequest: S.Schema<StopSessionRequest>;
+export interface StopSessionResponseBodyCase0 {
+    session: Session;
+}
+export declare const StopSessionResponseBodyCase0: S.Schema<StopSessionResponseBodyCase0>;
+export interface StopSessionResponseBodyCase1 {
+    snapshot: Snapshot;
+    sandbox: NamedSandbox;
+    session: Session;
+}
+export declare const StopSessionResponseBodyCase1: S.Schema<StopSessionResponseBodyCase1>;
+export type StopSessionResponseBody = StopSessionResponseBodyCase0 | StopSessionResponseBodyCase1;
+export declare const StopSessionResponseBody: S.Schema<StopSessionResponseBody>;
+export type StopSessionResponse = StopSessionResponseBody;
+export declare const StopSessionResponse: S.Schema<StopSessionResponse>;
+/** Resources to define the VM */
+export type UpdateSandboxRequestResources = CreateSandboxesByNameForkRequestResources;
+export declare const UpdateSandboxRequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+/** The runtime environment for the sandbox. Determines the pre-installed language runtimes and tools available. */
+export type UpdateSandboxRequestRuntime = "node22" | "node24" | "node26" | "python3.13";
+export declare const UpdateSandboxRequestRuntime: any;
+/** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+export type UpdateSandboxRequestSnapshotExpiration = unknown | number;
+export declare const UpdateSandboxRequestSnapshotExpiration: S.Schema<UpdateSandboxRequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type UpdateSandboxRequestKeepLastSnapshotsCase1Expiration = unknown | number;
+export declare const UpdateSandboxRequestKeepLastSnapshotsCase1Expiration: S.Schema<UpdateSandboxRequestKeepLastSnapshotsCase1Expiration>;
+export interface UpdateSandboxRequestKeepLastSnapshotsCase1 {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: UpdateSandboxRequestKeepLastSnapshotsCase1Expiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const UpdateSandboxRequestKeepLastSnapshotsCase1: S.Schema<UpdateSandboxRequestKeepLastSnapshotsCase1>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. Set to null to clear. */
+export type UpdateSandboxRequestKeepLastSnapshots = string | UpdateSandboxRequestKeepLastSnapshotsCase1;
+export declare const UpdateSandboxRequestKeepLastSnapshots: S.Schema<UpdateSandboxRequestKeepLastSnapshots>;
+/** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+export type UpdateSandboxRequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const UpdateSandboxRequestNetworkPolicyCase0Mode: any;
+/** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+export type UpdateSandboxRequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0AllowedDomainsList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0AllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+export type UpdateSandboxRequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0AllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type UpdateSandboxRequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItem {
+    /** The domain (or pattern) of requests to add headers for. Supports wildcards like *.example.com. */
+    domain: string;
+    /** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+    headers: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItem: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItem>;
+/** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesList = Array<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesList>;
+/** Network access policy for the sandbox.\n Controls which external hosts the sandbox can communicate with.\n Use \"allow-all\" mode to allow all traffic, \"deny-all\" to block all traffic or \"custom\" to provide specific rules. */
+export interface UpdateSandboxRequestNetworkPolicyCase0 {
+    /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+    mode: UpdateSandboxRequestNetworkPolicyCase0Mode | (string & {});
+    /** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+    allowedDomains?: UpdateSandboxRequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: UpdateSandboxRequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: UpdateSandboxRequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: UpdateSandboxRequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase0: S.Schema<UpdateSandboxRequestNetworkPolicyCase0>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase0List: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    forwardURL?: string;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueList = Array<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueList>;
+/** A rule applied to requests matching a domain in the network policy. Only one of `transform` or `forwardURL` can be specified per rule. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1Map: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1Map>;
+export type UpdateSandboxRequestNetworkPolicyCase1Allow = UpdateSandboxRequestNetworkPolicyCase1AllowCase0List | UpdateSandboxRequestNetworkPolicyCase1AllowCase1Map;
+export declare const UpdateSandboxRequestNetworkPolicyCase1Allow: S.Schema<UpdateSandboxRequestNetworkPolicyCase1Allow>;
+export type UpdateSandboxRequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1SubnetsAllowList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1SubnetsAllowList>;
+export type UpdateSandboxRequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1SubnetsDenyList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1SubnetsDenyList>;
+export interface UpdateSandboxRequestNetworkPolicyCase1Subnets {
+    allow?: UpdateSandboxRequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: UpdateSandboxRequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase1Subnets: S.Schema<UpdateSandboxRequestNetworkPolicyCase1Subnets>;
+export interface UpdateSandboxRequestNetworkPolicyCase1 {
+    allow?: UpdateSandboxRequestNetworkPolicyCase1Allow;
+    subnets?: UpdateSandboxRequestNetworkPolicyCase1Subnets;
+}
+export declare const UpdateSandboxRequestNetworkPolicyCase1: S.Schema<UpdateSandboxRequestNetworkPolicyCase1>;
+export type UpdateSandboxRequestNetworkPolicy = UpdateSandboxRequestNetworkPolicyCase0 | UpdateSandboxRequestNetworkPolicyCase1;
+export declare const UpdateSandboxRequestNetworkPolicy: S.Schema<UpdateSandboxRequestNetworkPolicy>;
+/** Default environment variables for the sandbox. Set to empty object to clear. */
+export type UpdateSandboxRequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSandboxRequestEnvMap: S.Schema<UpdateSandboxRequestEnvMap>;
+/** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+export type UpdateSandboxRequestPortsList = Array<number>;
+export declare const UpdateSandboxRequestPortsList: S.Schema<UpdateSandboxRequestPortsList>;
+/** Key-value tags to associate with the sandbox. Replaces existing tags. Set to empty object to clear. Maximum 5 tags. */
+export type UpdateSandboxRequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSandboxRequestTagsMap: S.Schema<UpdateSandboxRequestTagsMap>;
+export interface UpdateSandboxRequest {
+    /** The sandbox to update. */
+    name: string;
+    /** The project ID that owns the named sandbox. When provided, takes precedence over OIDC project context. */
+    projectId?: string;
+    /** Whether to automatically resume a stopped named sandbox by creating a new instance from its snapshot. Defaults to false. */
+    resume?: boolean;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkRequestResources;
+    /** The runtime environment for the sandbox. Determines the pre-installed language runtimes and tools available. */
+    runtime?: UpdateSandboxRequestRuntime | (string & {});
+    /** Maximum duration in milliseconds that the sandbox can run before being automatically stopped. */
+    timeout?: number;
+    /** Whether the sandbox persists its state across restarts via automatic snapshots. */
+    persistent?: boolean;
+    /** Default snapshot expiration time in milliseconds. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: UpdateSandboxRequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. Set to null to clear. */
+    keepLastSnapshots?: UpdateSandboxRequestKeepLastSnapshots;
+    networkPolicy?: UpdateSandboxRequestNetworkPolicy;
+    /** Default environment variables for the sandbox. Set to empty object to clear. */
+    env?: UpdateSandboxRequestEnvMap;
+    /** List of ports to expose from the sandbox. Each port will be accessible via a unique URL. Maximum of 15 ports can be exposed. */
+    ports?: UpdateSandboxRequestPortsList;
+    /** The snapshot ID to set as the current snapshot. Must be active and belong to the same project. */
+    currentSnapshotId?: string;
+    /** Key-value tags to associate with the sandbox. Replaces existing tags. Set to empty object to clear. Maximum 5 tags. */
+    tags?: UpdateSandboxRequestTagsMap;
+}
+export declare const UpdateSandboxRequest: S.Schema<UpdateSandboxRequest>;
+export type UpdateSandboxResponseBodyCase0RoutesList = Array<SandboxPublicRoute>;
+export declare const UpdateSandboxResponseBodyCase0RoutesList: S.Schema<UpdateSandboxResponseBodyCase0RoutesList>;
+export interface UpdateSandboxResponseBodyCase0 {
+    routes: UpdateSandboxResponseBodyCase0RoutesList;
+    sandbox: NamedSandbox;
+}
+export declare const UpdateSandboxResponseBodyCase0: S.Schema<UpdateSandboxResponseBodyCase0>;
+export type UpdateSandboxResponseBodyCase1RoutesList = Array<SandboxPublicRoute>;
+export declare const UpdateSandboxResponseBodyCase1RoutesList: S.Schema<UpdateSandboxResponseBodyCase1RoutesList>;
+export interface UpdateSandboxResponseBodyCase1 {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: UpdateSandboxResponseBodyCase1RoutesList;
+    resumed: boolean;
+}
+export declare const UpdateSandboxResponseBodyCase1: S.Schema<UpdateSandboxResponseBodyCase1>;
+export type UpdateSandboxResponseBody = UpdateSandboxResponseBodyCase0 | UpdateSandboxResponseBodyCase1;
+export declare const UpdateSandboxResponseBody: S.Schema<UpdateSandboxResponseBody>;
+export type UpdateSandboxResponse = UpdateSandboxResponseBody;
+export declare const UpdateSandboxResponse: S.Schema<UpdateSandboxResponse>;
+/** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0Mode: any;
+/** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+export type UpdateSessionNetworkPolicyRequestBodyCase0AllowedDomainsList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0AllowedDomainsList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0AllowedDomainsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0AllowedCIDRsList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0AllowedCIDRsList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0AllowedCIDRsList>;
+/** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0DeniedCIDRsList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0DeniedCIDRsList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchMethodList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatch: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatch>;
+export interface UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItem {
+    /** The domain (or pattern) of requests to add headers for. Supports wildcards like *.example.com. */
+    domain: string;
+    /** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+    headers: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap;
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatch;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItem: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItem>;
+/** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesList = Array<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesList>;
+/** Network access policy for the sandbox.\n Controls which external hosts the sandbox can communicate with.\n Use \"allow-all\" mode to allow all traffic, \"deny-all\" to block all traffic or \"custom\" to provide specific rules. */
+export interface UpdateSessionNetworkPolicyRequestBodyCase0 {
+    /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
+    mode: UpdateSessionNetworkPolicyRequestBodyCase0Mode | (string & {});
+    /** List of domain names the sandbox is allowed to connect to. Only applies when mode is \"custom\". Supports wildcard patterns (e.g., \"*.example.com\" matches all subdomains). */
+    allowedDomains?: UpdateSessionNetworkPolicyRequestBodyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: UpdateSessionNetworkPolicyRequestBodyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: UpdateSessionNetworkPolicyRequestBodyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesList;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchMethodList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersList>;
+/** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+export interface UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchMethodList;
+    /** Query-string entry matchers. Multiple entries are ANDed. Query parameter names and values are both compared case-sensitively (RFC 3986). When a request has multiple values for the same key, any matching value satisfies the matcher. */
+    queryString?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** Header matchers. Multiple entries are ANDed. Header names are compared case-insensitively (RFC 9110); header values are compared case-sensitively. When a request has multiple values for the same header, any matching value satisfies the matcher. */
+    headers?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatch: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatch>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItem {
+    headers?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItem: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItem>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformList = Array<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformList>;
+export interface UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItem {
+    /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
+    match?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatch;
+    transform?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    forwardURL?: string;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItem: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItem>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueList = Array<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueList>;
+/** A rule applied to requests matching a domain in the network policy. Only one of `transform` or `forwardURL` can be specified per rule. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1Map = {
+    [key: string]: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueList | undefined;
+};
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1Map: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1Map>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1Allow = UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List | UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1Map;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1Allow: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1Allow>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1SubnetsAllowList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1SubnetsAllowList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1SubnetsAllowList>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1SubnetsDenyList = Array<string>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1SubnetsDenyList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1SubnetsDenyList>;
+export interface UpdateSessionNetworkPolicyRequestBodyCase1Subnets {
+    allow?: UpdateSessionNetworkPolicyRequestBodyCase1SubnetsAllowList;
+    deny?: UpdateSessionNetworkPolicyRequestBodyCase1SubnetsDenyList;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1Subnets: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1Subnets>;
+export interface UpdateSessionNetworkPolicyRequestBodyCase1 {
+    allow?: UpdateSessionNetworkPolicyRequestBodyCase1Allow;
+    subnets?: UpdateSessionNetworkPolicyRequestBodyCase1Subnets;
+}
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1>;
+export type UpdateSessionNetworkPolicyRequestBody = UpdateSessionNetworkPolicyRequestBodyCase0 | UpdateSessionNetworkPolicyRequestBodyCase1;
+export declare const UpdateSessionNetworkPolicyRequestBody: S.Schema<UpdateSessionNetworkPolicyRequestBody>;
+export interface UpdateSessionNetworkPolicyRequest {
+    /** The unique identifier of the session to update the network policy for. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    body?: UpdateSessionNetworkPolicyRequestBody;
+}
+export declare const UpdateSessionNetworkPolicyRequest: S.Schema<UpdateSessionNetworkPolicyRequest>;
+export interface UpdateSessionNetworkPolicyResponse {
+    session: Session;
+}
+export declare const UpdateSessionNetworkPolicyResponse: S.Schema<UpdateSessionNetworkPolicyResponse>;
+export interface WriteSessionFilesRequest {
+    /** The unique identifier of the session to write files to. */
+    sessionId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The target directory where the tarball contents will be extracted. If not specified, files are extracted to the sandbox home directory. */
+    xCwd?: string;
+}
+export declare const WriteSessionFilesRequest: S.Schema<WriteSessionFilesRequest>;
+export type WriteSessionFilesResponse = unknown;
+export declare const WriteSessionFilesResponse: S.Schema<WriteSessionFilesResponse>;
+export type CreateSandboxesByNameForkError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Fork a named sandbox Forks a named sandbox, creating a new named sandbox from the source's configuration. Resources, timeout, ports, tags, network policy, mounts, Connect network, image, persistence, snapshot settings and — unlike the SDK-side fork — environment variables are copied from the source automatically (`interactive` is not). When the source has a snapshot the fork starts from it; otherwise it starts from the source's runtime/image. Any field provided in the request body overrides the value copied from the source. */
+export declare const createSandboxesByNameFork: API.OperationMethod<CreateSandboxesByNameForkRequest, CreateSandboxesByNameForkResponse, CreateSandboxesByNameForkError, VercelOpContext>;
+export type CreateSandboxesV2Error = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Create a named sandbox Creates a named sandbox environment. Named sandboxes have a unique name within a project and support automatic snapshotting on shutdown. */
+export declare const createSandboxesV2: API.OperationMethod<CreateSandboxesV2Request, CreateSandboxesV2Response, CreateSandboxesV2Error, VercelOpContext>;
+export type CreateSandboxesV3Error = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Create a named sandbox Creates a named sandbox environment. Named sandboxes have a unique name within a project and support automatic snapshotting on shutdown. Unlike v2, this version has no `runtime` parameter: when no `image` is provided (and the sandbox is not restored from a snapshot), the sandbox is created from the default universal image. */
+export declare const createSandboxesV3: API.OperationMethod<CreateSandboxesV3Request, CreateSandboxesV3Response, CreateSandboxesV3Error, VercelOpContext>;
+export type CreateSessionDirectoryError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Create a directory Creates a new directory in a session's filesystem. By default, parent directories are created recursively if they don't exist (similar to `mkdir -p`). */
+export declare const createSessionDirectory: API.OperationMethod<CreateSessionDirectoryRequest, CreateSessionDirectoryResponse, CreateSessionDirectoryError, VercelOpContext>;
+export type CreateSessionSnapshotError = BadRequest | PaymentRequired | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Create a snapshot Creates a point-in-time snapshot of a running session's filesystem. Snapshots can be used to quickly restore a session to a previous state or to create new sessions with pre-configured environments. The session must be running and able to accept commands for a snapshot to be created. The session will be terminated after the snapshot is created. */
+export declare const createSessionSnapshot: API.OperationMethod<CreateSessionSnapshotRequest, CreateSessionSnapshotResponse, CreateSessionSnapshotError, VercelOpContext>;
+export type DeleteDriveError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
+/** Delete a drive Deletes a drive by project and name. Attached drives cannot be deleted. Stop or replace the session currently using the drive before retrying deletion. Drives are in private beta. Register your interest to get access: https://vercel.com/changelog/drives-for-vercel-sandbox-in-private-beta */
+export declare const deleteDrive: API.OperationMethod<DeleteDriveRequest, DeleteDriveResponse, DeleteDriveError, VercelOpContext>;
+export type DeleteSandboxError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Delete a sandbox Deletes a sandbox by name. If sandboxes are currently running, they will be stopped first. This operation deletes all sandbox entities with the given name and the named sandbox metadata. */
+export declare const deleteSandbox: API.OperationMethod<DeleteSandboxRequest, DeleteSandboxResponse, DeleteSandboxError, VercelOpContext>;
+export type DeleteSessionSnapshotError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Delete a snapshot Permanently deletes a snapshot and frees its associated storage. This action cannot be undone. After deletion, the snapshot can no longer be used to create new sessions. */
+export declare const deleteSessionSnapshot: API.OperationMethod<DeleteSessionSnapshotRequest, DeleteSessionSnapshotResponse, DeleteSessionSnapshotError, VercelOpContext>;
+export type ExtendSessionTimeoutError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Extend session timeout Extends the maximum execution time of a running session. The session must be active and able to accept commands. The total timeout cannot exceed the maximum allowed limit for your account. */
+export declare const extendSessionTimeout: API.OperationMethod<ExtendSessionTimeoutRequest, ExtendSessionTimeoutResponse, ExtendSessionTimeoutError, VercelOpContext>;
+export type GetNamedSandboxError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Get a named sandbox Retrieves a named sandbox by name, including its current sandbox and routes. If the sandbox is stopped and resume is true, a new sandbox will be created from the most recent snapshot. */
+export declare const getNamedSandbox: API.OperationMethod<GetNamedSandboxRequest, GetNamedSandboxResponse, GetNamedSandboxError, VercelOpContext>;
+export type GetOrCreateDriveError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Get or create a drive Gets an existing drive by project and name, or creates it when it does not exist. Drives are in private beta. Register your interest to get access: https://vercel.com/changelog/drives-for-vercel-sandbox-in-private-beta */
+export declare const getOrCreateDrive: API.OperationMethod<GetOrCreateDriveRequest, GetOrCreateDriveResponse, GetOrCreateDriveError, VercelOpContext>;
+export type GetSessionError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get a session Retrieves detailed information about a specific session, including its current status, resource configuration, and exposed routes. */
+export declare const getSession: API.OperationMethod<GetSessionRequest, GetSessionResponse, GetSessionError, VercelOpContext>;
+export type GetSessionCommandError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Get a command Retrieves the current status and details of a command executed in a session. Use the `wait` parameter to block until the command finishes execution. */
+export declare const getSessionCommand: API.OperationMethod<GetSessionCommandRequest, GetSessionCommandResponse, GetSessionCommandError, VercelOpContext>;
+export type GetSessionCommandLogsError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Stream command logs Streams the output of a command in real-time using newline-delimited JSON (ND-JSON). Each entry includes the output data and stream type. Stream types include `stdout`, `stderr`, and `error` (for stream failures). */
+export declare const getSessionCommandLogs: API.OperationMethod<GetSessionCommandLogsRequest, GetSessionCommandLogsResponse, GetSessionCommandLogsError, VercelOpContext>;
+export type GetSessionSnapshotError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get a snapshot Retrieves detailed information about a specific snapshot, including its creation time, size, expiration date, and the source session it was created from. */
+export declare const getSessionSnapshot: API.OperationMethod<GetSessionSnapshotRequest, GetSessionSnapshotResponse, GetSessionSnapshotError, VercelOpContext>;
+export type KillSessionCommandError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Kill a command Sends a signal to terminate a running command in a session. The signal can be used to gracefully stop (SIGTERM) or forcefully kill (SIGKILL) the process. The command must still be running for this operation to succeed. */
+export declare const killSessionCommand: API.OperationMethod<KillSessionCommandRequest, KillSessionCommandResponse, KillSessionCommandError, VercelOpContext>;
+export type ListDrivesError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List drives Retrieves a paginated list of drives belonging to a specific project. Drives are in private beta. Register your interest to get access: https://vercel.com/changelog/drives-for-vercel-sandbox-in-private-beta */
+export declare const listDrives: API.OperationMethod<ListDrivesRequest, ListDrivesResponse, ListDrivesError, VercelOpContext>;
+export type ListSandboxesError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List sandboxes Retrieves a paginated list of named sandboxes belonging to a specific project. Results can be sorted by creation time or name, and optionally filtered by name prefix or status. */
+export declare const listSandboxes: API.OperationMethod<ListSandboxesRequest, ListSandboxesResponse, ListSandboxesError, VercelOpContext>;
+export type ListSessionCommandsError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List commands Retrieves a list of all commands that have been executed in a session, including their current status, exit codes, and execution times, ordered from the most recent to the oldest. */
+export declare const listSessionCommands: API.OperationMethod<ListSessionCommandsRequest, ListSessionCommandsResponse, ListSessionCommandsError, VercelOpContext>;
+export type ListSessionsError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List sessions Retrieves a paginated list of sessions belonging to a specific sandbox. Results are sorted by creation time and paginated using an opaque cursor. */
+export declare const listSessions: API.OperationMethod<ListSessionsRequest, ListSessionsResponse, ListSessionsError, VercelOpContext>;
+export type ListSessionSnapshotsError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List snapshots Retrieves a paginated list of snapshots for a specific project. */
+export declare const listSessionSnapshots: API.OperationMethod<ListSessionSnapshotsRequest, ListSessionSnapshotsResponse, ListSessionSnapshotsError, VercelOpContext>;
+export type ReadSessionFileError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Read a file Downloads the contents of a file from a session's filesystem. The file content is returned as a binary stream with appropriate Content-Disposition headers for file download. */
+export declare const readSessionFile: API.OperationMethod<ReadSessionFileRequest, ReadSessionFileResponse, ReadSessionFileError, VercelOpContext>;
+export type RunSessionCommandError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Execute a command Executes a shell command inside a running session. The command runs asynchronously and returns immediately with a command ID that can be used to track its progress and retrieve its output. Optionally, use the `wait` parameter to stream the command status until completion. */
+export declare const runSessionCommand: API.OperationMethod<RunSessionCommandRequest, RunSessionCommandResponse, RunSessionCommandError, VercelOpContext>;
+export type StopSessionError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Stop a session Stops a running session and releases its allocated resources. All running processes within the session will be terminated. This action cannot be undone. A stopped session cannot be restarted. */
+export declare const stopSession: API.OperationMethod<StopSessionRequest, StopSessionResponse, StopSessionError, VercelOpContext>;
+export type UpdateSandboxError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Update a sandbox Updates the configuration of a sandbox. Only the provided fields will be modified; omitted fields remain unchanged. */
+export declare const updateSandbox: API.OperationMethod<UpdateSandboxRequest, UpdateSandboxResponse, UpdateSandboxError, VercelOpContext>;
+export type UpdateSessionNetworkPolicyError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Update network policy Replaces the network access policy of a running session. Use this to control which external hosts the session can communicate with. This is a full replacement. Any previously configured network rules will be overwritten. */
+export declare const updateSessionNetworkPolicy: API.OperationMethod<UpdateSessionNetworkPolicyRequest, UpdateSessionNetworkPolicyResponse, UpdateSessionNetworkPolicyError, VercelOpContext>;
+export type WriteSessionFilesError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Write files Uploads and extracts files to a session's filesystem. Files must be uploaded as a gzipped tarball (`.tar.gz`) with the `Content-Type` header set to `application/gzip`. The tarball contents are extracted to the session's working directory, or to a custom directory specified via the `x-cwd` header. */
+export declare const writeSessionFiles: API.OperationMethod<WriteSessionFilesRequest, WriteSessionFilesResponse, WriteSessionFilesError, VercelOpContext>;
+//# sourceMappingURL=sandboxes.d.ts.map