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

package/lib/services/sandboxes.d.ts

@@ -0,0 +1,2777 @@
+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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0Mode: 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedDomainsList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedCIDRsList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath {
+    /** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem {
+    /** Matcher for the entry key (header name or query key). */
+    key?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** Matcher for the entry value. */
+    value?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItem {
+    /** 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: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItem>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase0 {
+    /** 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: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0Mode | (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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include username, password, query string, or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueList>;
+/** 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 CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Allow = CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase0List | CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicy = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0 | CreateSandboxesByNameForkV2RequestNetworkPolicyCase1;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicy: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicy>;
+/** Resources to define the VM */
+export interface CreateSandboxesByNameForkV2RequestResources {
+    /** 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 CreateSandboxesByNameForkV2RequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** 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 CreateSandboxesByNameForkV2RequestPortsList = Array<number>;
+export declare const CreateSandboxesByNameForkV2RequestPortsList: S.Schema<CreateSandboxesByNameForkV2RequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesByNameForkV2RequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestEnvMap: S.Schema<CreateSandboxesByNameForkV2RequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesByNameForkV2RequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesByNameForkV2RequestMountsValueMode: any;
+export interface CreateSandboxesByNameForkV2RequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesByNameForkV2RequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesByNameForkV2RequestMountsValue: S.Schema<CreateSandboxesByNameForkV2RequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesByNameForkV2RequestMountsMap = {
+    [key: string]: CreateSandboxesByNameForkV2RequestMountsValue | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestMountsMap: S.Schema<CreateSandboxesByNameForkV2RequestMountsMap>;
+/** The Vercel region in which to create the sandbox. */
+export type CreateSandboxesByNameForkV2RequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesByNameForkV2RequestRegion: any;
+export type CreateSandboxesByNameForkV2RequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesByNameForkV2RequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type CreateSandboxesByNameForkV2RequestFailoverRegionsList = Array<CreateSandboxesByNameForkV2RequestFailoverRegionsItem | (string & {})>;
+export declare const CreateSandboxesByNameForkV2RequestFailoverRegionsList: S.Schema<CreateSandboxesByNameForkV2RequestFailoverRegionsList>;
+/** 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 CreateSandboxesByNameForkV2RequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesByNameForkV2RequestSnapshotExpiration: S.Schema<CreateSandboxesByNameForkV2RequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesByNameForkV2RequestKeepLastSnapshotsExpiration = unknown | number;
+export declare const CreateSandboxesByNameForkV2RequestKeepLastSnapshotsExpiration: S.Schema<CreateSandboxesByNameForkV2RequestKeepLastSnapshotsExpiration>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. */
+export interface CreateSandboxesByNameForkV2RequestKeepLastSnapshots {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesByNameForkV2RequestKeepLastSnapshotsExpiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesByNameForkV2RequestKeepLastSnapshots: S.Schema<CreateSandboxesByNameForkV2RequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesByNameForkV2RequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV2RequestTagsMap: S.Schema<CreateSandboxesByNameForkV2RequestTagsMap>;
+export interface CreateSandboxesByNameForkV2Request {
+    /** 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?: CreateSandboxesByNameForkV2RequestNetworkPolicy;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkV2RequestResources;
+    /** 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?: CreateSandboxesByNameForkV2RequestPortsList;
+    /** 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?: CreateSandboxesByNameForkV2RequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesByNameForkV2RequestMountsMap;
+    /** The Vercel region in which to create the sandbox. */
+    region?: CreateSandboxesByNameForkV2RequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: CreateSandboxesByNameForkV2RequestFailoverRegionsList;
+    /** 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?: CreateSandboxesByNameForkV2RequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. */
+    keepLastSnapshots?: CreateSandboxesByNameForkV2RequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesByNameForkV2RequestTagsMap;
+}
+export declare const CreateSandboxesByNameForkV2Request: S.Schema<CreateSandboxesByNameForkV2Request>;
+/** The status of the current sandbox. */
+export type NamedSandboxStatus = "running" | "stopped" | "stopping";
+export declare const NamedSandboxStatus: any;
+/** The regions the sandbox fails over to. Empty when it does not fail over. */
+export type NamedSandboxFailoverRegionsItem = "arn1" | "bom1" | "cdg1" | "cle1" | "cpt1" | "dub1" | "fra1" | "gru1" | "hkg1" | "hnd1" | "iad1" | "icn1" | "kix1" | "lhr1" | "pdx1" | "sfo1" | "sin1" | "syd1" | "yul1";
+export declare const NamedSandboxFailoverRegionsItem: any;
+/** The regions the sandbox fails over to. Empty when it does not fail over. */
+export type NamedSandboxFailoverRegionsList = Array<NamedSandboxFailoverRegionsItem>;
+export declare const NamedSandboxFailoverRegionsList: S.Schema<NamedSandboxFailoverRegionsList>;
+/** 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;
+    s3Key?: string;
+}
+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 pinned to: the region stored on the sandbox, otherwise the platform default. Where a running session actually landed is reported by `session.region`. */
+    region?: string;
+    /** The regions the sandbox fails over to. Empty when it does not fail over. */
+    failoverRegions?: NamedSandboxFailoverRegionsList;
+    /** 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 CreateSandboxesByNameForkV2ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesByNameForkV2ResponseRoutesList: S.Schema<CreateSandboxesByNameForkV2ResponseRoutesList>;
+export interface CreateSandboxesByNameForkV2Response {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesByNameForkV2ResponseRoutesList;
+}
+export declare const CreateSandboxesByNameForkV2Response: S.Schema<CreateSandboxesByNameForkV2Response>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0Mode: 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedDomainsList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedCIDRsList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItem {
+    /** 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: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItem>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase0 {
+    /** 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: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0Mode | (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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase0: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase0>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include username, password, query string, or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueList>;
+/** 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 CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Allow = CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase0List | CreateSandboxesByNameForkV3RequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesByNameForkV3RequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesByNameForkV3RequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicyCase1: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicyCase1>;
+export type CreateSandboxesByNameForkV3RequestNetworkPolicy = CreateSandboxesByNameForkV3RequestNetworkPolicyCase0 | CreateSandboxesByNameForkV3RequestNetworkPolicyCase1;
+export declare const CreateSandboxesByNameForkV3RequestNetworkPolicy: S.Schema<CreateSandboxesByNameForkV3RequestNetworkPolicy>;
+/** Resources to define the VM */
+export type CreateSandboxesByNameForkV3RequestResources = CreateSandboxesByNameForkV2RequestResources;
+export declare const CreateSandboxesByNameForkV3RequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** 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 CreateSandboxesByNameForkV3RequestPortsList = Array<number>;
+export declare const CreateSandboxesByNameForkV3RequestPortsList: S.Schema<CreateSandboxesByNameForkV3RequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesByNameForkV3RequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestEnvMap: S.Schema<CreateSandboxesByNameForkV3RequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesByNameForkV3RequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesByNameForkV3RequestMountsValueMode: any;
+export interface CreateSandboxesByNameForkV3RequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesByNameForkV3RequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesByNameForkV3RequestMountsValue: S.Schema<CreateSandboxesByNameForkV3RequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesByNameForkV3RequestMountsMap = {
+    [key: string]: CreateSandboxesByNameForkV3RequestMountsValue | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestMountsMap: S.Schema<CreateSandboxesByNameForkV3RequestMountsMap>;
+/** The Vercel region in which to create the sandbox. */
+export type CreateSandboxesByNameForkV3RequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesByNameForkV3RequestRegion: any;
+export type CreateSandboxesByNameForkV3RequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesByNameForkV3RequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type CreateSandboxesByNameForkV3RequestFailoverRegionsList = Array<CreateSandboxesByNameForkV3RequestFailoverRegionsItem | (string & {})>;
+export declare const CreateSandboxesByNameForkV3RequestFailoverRegionsList: S.Schema<CreateSandboxesByNameForkV3RequestFailoverRegionsList>;
+/** Default snapshot expiration time in milliseconds. Defaults to 7 days. 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 CreateSandboxesByNameForkV3RequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesByNameForkV3RequestSnapshotExpiration: S.Schema<CreateSandboxesByNameForkV3RequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1Expiration = unknown | number;
+export declare const CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1Expiration: S.Schema<CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1Expiration>;
+export interface CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1 {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1Expiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1: S.Schema<CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. Persistent sandboxes default to keeping only the last snapshot (evicted snapshots are deleted). Set to null to disable the limit. */
+export type CreateSandboxesByNameForkV3RequestKeepLastSnapshots = string | CreateSandboxesByNameForkV3RequestKeepLastSnapshotsCase1;
+export declare const CreateSandboxesByNameForkV3RequestKeepLastSnapshots: S.Schema<CreateSandboxesByNameForkV3RequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesByNameForkV3RequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesByNameForkV3RequestTagsMap: S.Schema<CreateSandboxesByNameForkV3RequestTagsMap>;
+export interface CreateSandboxesByNameForkV3Request {
+    /** 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?: CreateSandboxesByNameForkV3RequestNetworkPolicy;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkV2RequestResources;
+    /** 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?: CreateSandboxesByNameForkV3RequestPortsList;
+    /** 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?: CreateSandboxesByNameForkV3RequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesByNameForkV3RequestMountsMap;
+    /** The Vercel region in which to create the sandbox. */
+    region?: CreateSandboxesByNameForkV3RequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: CreateSandboxesByNameForkV3RequestFailoverRegionsList;
+    /** 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. Defaults to 7 days. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: CreateSandboxesByNameForkV3RequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. Persistent sandboxes default to keeping only the last snapshot (evicted snapshots are deleted). Set to null to disable the limit. */
+    keepLastSnapshots?: CreateSandboxesByNameForkV3RequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesByNameForkV3RequestTagsMap;
+}
+export declare const CreateSandboxesByNameForkV3Request: S.Schema<CreateSandboxesByNameForkV3Request>;
+export type CreateSandboxesByNameForkV3ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesByNameForkV3ResponseRoutesList: S.Schema<CreateSandboxesByNameForkV3ResponseRoutesList>;
+export interface CreateSandboxesByNameForkV3Response {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesByNameForkV3ResponseRoutesList;
+}
+export declare const CreateSandboxesByNameForkV3Response: S.Schema<CreateSandboxesByNameForkV3Response>;
+/** The number of milliseconds after which the snapshot will expire and be deleted. Use 0 for no expiration. */
+export type CreateSandboxesSessionsBySessionIdSnapshotV2RequestExpiration = unknown | number;
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV2RequestExpiration: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV2RequestExpiration>;
+export interface CreateSandboxesSessionsBySessionIdSnapshotV2Request {
+    /** 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?: CreateSandboxesSessionsBySessionIdSnapshotV2RequestExpiration;
+}
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV2Request: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV2Request>;
+/** The regions where the snapshot is available. */
+export type SnapshotRegionsList = Array<string>;
+export declare const SnapshotRegionsList: S.Schema<SnapshotRegionsList>;
+/** 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 regions where the snapshot is available. */
+    regions?: SnapshotRegionsList;
+    /** 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 CreateSandboxesSessionsBySessionIdSnapshotV2Response {
+    snapshot: Snapshot;
+    session: Session;
+}
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV2Response: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV2Response>;
+/** The number of milliseconds after which the snapshot will expire and be deleted. Defaults to 7 days when neither this field nor the sandbox configuration specifies an expiration. Use 0 for no expiration. */
+export type CreateSandboxesSessionsBySessionIdSnapshotV3RequestExpiration = unknown | number;
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV3RequestExpiration: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV3RequestExpiration>;
+export interface CreateSandboxesSessionsBySessionIdSnapshotV3Request {
+    /** 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. Defaults to 7 days when neither this field nor the sandbox configuration specifies an expiration. Use 0 for no expiration. */
+    expiration?: CreateSandboxesSessionsBySessionIdSnapshotV3RequestExpiration;
+}
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV3Request: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV3Request>;
+export interface CreateSandboxesSessionsBySessionIdSnapshotV3Response {
+    snapshot: Snapshot;
+    session: Session;
+}
+export declare const CreateSandboxesSessionsBySessionIdSnapshotV3Response: S.Schema<CreateSandboxesSessionsBySessionIdSnapshotV3Response>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 username, password, 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 = CreateSandboxesByNameForkV2RequestResources;
+export declare const CreateSandboxesV2RequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** 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>;
+/** The Vercel region in which to create the sandbox. */
+export type CreateSandboxesV2RequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV2RequestRegion: any;
+export type CreateSandboxesV2RequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV2RequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type CreateSandboxesV2RequestFailoverRegionsList = Array<CreateSandboxesV2RequestFailoverRegionsItem | (string & {})>;
+export declare const CreateSandboxesV2RequestFailoverRegionsList: S.Schema<CreateSandboxesV2RequestFailoverRegionsList>;
+/** 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?: CreateSandboxesByNameForkV2RequestResources;
+    /** 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;
+    /** The Vercel region in which to create the sandbox. */
+    region?: CreateSandboxesV2RequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: CreateSandboxesV2RequestFailoverRegionsList;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 username, password, 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 = CreateSandboxesByNameForkV2RequestResources;
+export declare const CreateSandboxesV3RequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** 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>;
+/** The Vercel region in which to create the sandbox. */
+export type CreateSandboxesV3RequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV3RequestRegion: any;
+export type CreateSandboxesV3RequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV3RequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type CreateSandboxesV3RequestFailoverRegionsList = Array<CreateSandboxesV3RequestFailoverRegionsItem | (string & {})>;
+export declare const CreateSandboxesV3RequestFailoverRegionsList: S.Schema<CreateSandboxesV3RequestFailoverRegionsList>;
+/** 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?: CreateSandboxesByNameForkV2RequestResources;
+    /** 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;
+    /** The Vercel region in which to create the sandbox. */
+    region?: CreateSandboxesV3RequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: CreateSandboxesV3RequestFailoverRegionsList;
+    /** 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>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0Mode: 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 CreateSandboxesV4RequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0AllowedDomainsList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0AllowedCIDRsList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0DeniedCIDRsList>;
+/** HTTP headers to inject into requests for this domain. Existing headers with the same name will be overridden. */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatch>;
+export interface CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItem {
+    /** 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: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItemMatch;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItem>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase0 {
+    /** 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: CreateSandboxesV4RequestNetworkPolicyCase0Mode | (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?: CreateSandboxesV4RequestNetworkPolicyCase0AllowedDomainsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is allowed to connect to. Traffic to these addresses bypasses domain-based restrictions. */
+    allowedCIDRs?: CreateSandboxesV4RequestNetworkPolicyCase0AllowedCIDRsList;
+    /** List of IP address ranges (in CIDR notation) the sandbox is blocked from connecting to. These rules take precedence over all allowed rules. */
+    deniedCIDRs?: CreateSandboxesV4RequestNetworkPolicyCase0DeniedCIDRsList;
+    /** HTTP header injection rules for outgoing requests matching specific domains. Traffic to matching domains will be intercepted instead of proxied through encrypted connections. */
+    injectionRules?: CreateSandboxesV4RequestNetworkPolicyCase0InjectionRulesList;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase0: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase0>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase0List = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase0List>;
+/** Match on the request path. Comparison is case-sensitive. */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** HTTP methods to match. Any single match succeeds (OR semantics). */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+    /** Match on the request path. Comparison is case-sensitive. */
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** HTTP methods to match. Any single match succeeds (OR semantics). */
+    method?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
+export interface CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
+    headers?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
+export interface CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItem {
+    /** 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?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
+    transform?: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
+    /** HTTP/1.1 proxy URL to forward traffic to. Must not include username, password, query string, or fragment. */
+    forwardURL?: string;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueItem>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueList>;
+/** 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 CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+};
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1Map>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1Allow = CreateSandboxesV4RequestNetworkPolicyCase1AllowCase0List | CreateSandboxesV4RequestNetworkPolicyCase1AllowCase1Map;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1Allow>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1SubnetsAllowList>;
+export type CreateSandboxesV4RequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1SubnetsDenyList>;
+export interface CreateSandboxesV4RequestNetworkPolicyCase1Subnets {
+    allow?: CreateSandboxesV4RequestNetworkPolicyCase1SubnetsAllowList;
+    deny?: CreateSandboxesV4RequestNetworkPolicyCase1SubnetsDenyList;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1Subnets>;
+export interface CreateSandboxesV4RequestNetworkPolicyCase1 {
+    allow?: CreateSandboxesV4RequestNetworkPolicyCase1Allow;
+    subnets?: CreateSandboxesV4RequestNetworkPolicyCase1Subnets;
+}
+export declare const CreateSandboxesV4RequestNetworkPolicyCase1: S.Schema<CreateSandboxesV4RequestNetworkPolicyCase1>;
+export type CreateSandboxesV4RequestNetworkPolicy = CreateSandboxesV4RequestNetworkPolicyCase0 | CreateSandboxesV4RequestNetworkPolicyCase1;
+export declare const CreateSandboxesV4RequestNetworkPolicy: S.Schema<CreateSandboxesV4RequestNetworkPolicy>;
+/** Resources to define the VM */
+export type CreateSandboxesV4RequestResources = CreateSandboxesByNameForkV2RequestResources;
+export declare const CreateSandboxesV4RequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** Clone a Git repository into the sandbox. */
+export type CreateSandboxesV4RequestSourceCase0 = CreateSandboxesV2RequestSourceCase0;
+export declare const CreateSandboxesV4RequestSourceCase0: S.Schema<CreateSandboxesV2RequestSourceCase0>;
+/** Download and extract a gzipped tarball into the sandbox. */
+export type CreateSandboxesV4RequestSourceCase1 = CreateSandboxesV2RequestSourceCase1;
+export declare const CreateSandboxesV4RequestSourceCase1: S.Schema<CreateSandboxesV2RequestSourceCase1>;
+/** Restore the sandbox filesystem from an existing snapshot. */
+export type CreateSandboxesV4RequestSourceCase2 = CreateSandboxesV2RequestSourceCase2;
+export declare const CreateSandboxesV4RequestSourceCase2: 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 CreateSandboxesV4RequestSource = CreateSandboxesV2RequestSourceCase0 | CreateSandboxesV2RequestSourceCase1 | CreateSandboxesV2RequestSourceCase2;
+export declare const CreateSandboxesV4RequestSource: S.Schema<CreateSandboxesV4RequestSource>;
+/** 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 CreateSandboxesV4RequestPortsList = Array<number>;
+export declare const CreateSandboxesV4RequestPortsList: S.Schema<CreateSandboxesV4RequestPortsList>;
+/** Default environment variables for the sandbox. These are inherited by all commands unless overridden. */
+export type CreateSandboxesV4RequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV4RequestEnvMap: S.Schema<CreateSandboxesV4RequestEnvMap>;
+/** Mount the drive read-only or read-write. */
+export type CreateSandboxesV4RequestMountsValueMode = "read-only" | "read-write";
+export declare const CreateSandboxesV4RequestMountsValueMode: any;
+export interface CreateSandboxesV4RequestMountsValue {
+    /** Name of the drive to mount. The drive must already exist. */
+    drive: string;
+    /** Mount the drive read-only or read-write. */
+    mode?: CreateSandboxesV4RequestMountsValueMode | (string & {});
+}
+export declare const CreateSandboxesV4RequestMountsValue: S.Schema<CreateSandboxesV4RequestMountsValue>;
+/** List of drives to mount to the sandbox at the provided path. */
+export type CreateSandboxesV4RequestMountsMap = {
+    [key: string]: CreateSandboxesV4RequestMountsValue | undefined;
+};
+export declare const CreateSandboxesV4RequestMountsMap: S.Schema<CreateSandboxesV4RequestMountsMap>;
+/** The Vercel region in which to create the sandbox. */
+export type CreateSandboxesV4RequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV4RequestRegion: any;
+export type CreateSandboxesV4RequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const CreateSandboxesV4RequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type CreateSandboxesV4RequestFailoverRegionsList = Array<CreateSandboxesV4RequestFailoverRegionsItem | (string & {})>;
+export declare const CreateSandboxesV4RequestFailoverRegionsList: S.Schema<CreateSandboxesV4RequestFailoverRegionsList>;
+/** Default snapshot expiration time in milliseconds. Defaults to 7 days. 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 CreateSandboxesV4RequestSnapshotExpiration = unknown | number;
+export declare const CreateSandboxesV4RequestSnapshotExpiration: S.Schema<CreateSandboxesV4RequestSnapshotExpiration>;
+/** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+export type CreateSandboxesV4RequestKeepLastSnapshotsCase1Expiration = unknown | number;
+export declare const CreateSandboxesV4RequestKeepLastSnapshotsCase1Expiration: S.Schema<CreateSandboxesV4RequestKeepLastSnapshotsCase1Expiration>;
+export interface CreateSandboxesV4RequestKeepLastSnapshotsCase1 {
+    /** Number of most recent snapshots to keep. */
+    count: number;
+    /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
+    expiration?: CreateSandboxesV4RequestKeepLastSnapshotsCase1Expiration;
+    /** Whether to immediately delete evicted snapshots. Defaults to true. */
+    deleteEvicted?: boolean;
+}
+export declare const CreateSandboxesV4RequestKeepLastSnapshotsCase1: S.Schema<CreateSandboxesV4RequestKeepLastSnapshotsCase1>;
+/** Protect the N most recent snapshots with different expiration/deletion behavior. Persistent sandboxes default to keeping only the last snapshot (evicted snapshots are deleted). Set to null to disable the limit. */
+export type CreateSandboxesV4RequestKeepLastSnapshots = string | CreateSandboxesV4RequestKeepLastSnapshotsCase1;
+export declare const CreateSandboxesV4RequestKeepLastSnapshots: S.Schema<CreateSandboxesV4RequestKeepLastSnapshots>;
+/** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+export type CreateSandboxesV4RequestTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxesV4RequestTagsMap: S.Schema<CreateSandboxesV4RequestTagsMap>;
+export interface CreateSandboxesV4Request {
+    /** 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?: CreateSandboxesV4RequestNetworkPolicy;
+    /** Resources to define the VM */
+    resources?: CreateSandboxesByNameForkV2RequestResources;
+    /** The source from which to initialize the sandbox filesystem. Can be a Git repository, a tarball URL, or an existing snapshot. */
+    source?: CreateSandboxesV4RequestSource;
+    /** 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?: CreateSandboxesV4RequestPortsList;
+    /** 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?: CreateSandboxesV4RequestEnvMap;
+    /** List of drives to mount to the sandbox at the provided path. */
+    mounts?: CreateSandboxesV4RequestMountsMap;
+    /** The Vercel region in which to create the sandbox. */
+    region?: CreateSandboxesV4RequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: CreateSandboxesV4RequestFailoverRegionsList;
+    /** 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. Defaults to 7 days. Set to 0 to disable expiration. When set, this value is used as the default expiration for all snapshots created for this sandbox. */
+    snapshotExpiration?: CreateSandboxesV4RequestSnapshotExpiration;
+    /** Protect the N most recent snapshots with different expiration/deletion behavior. Persistent sandboxes default to keeping only the last snapshot (evicted snapshots are deleted). Set to null to disable the limit. */
+    keepLastSnapshots?: CreateSandboxesV4RequestKeepLastSnapshots;
+    /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
+    tags?: CreateSandboxesV4RequestTagsMap;
+}
+export declare const CreateSandboxesV4Request: S.Schema<CreateSandboxesV4Request>;
+export type CreateSandboxesV4ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesV4ResponseRoutesList: S.Schema<CreateSandboxesV4ResponseRoutesList>;
+export interface CreateSandboxesV4Response {
+    sandbox: NamedSandbox;
+    session: Session;
+    routes: CreateSandboxesV4ResponseRoutesList;
+}
+export declare const CreateSandboxesV4Response: S.Schema<CreateSandboxesV4Response>;
+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>;
+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 ID. */
+    id: string;
+    /** 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;
+    /** When true, snapshots of the deleted sandbox that are not referenced by any other sandbox are also deleted asynchronously. Defaults to false. */
+    deleteOrphanSnapshots?: 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 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" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+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>;
+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?: 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 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>;
+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, up to 5 hours. 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 = CreateSandboxesByNameForkV2RequestResources;
+export declare const UpdateSandboxRequestResources: S.Schema<CreateSandboxesByNameForkV2RequestResources>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 username, password, 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>;
+/** The Vercel region in which to create the sandbox. */
+export type UpdateSandboxRequestRegion = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const UpdateSandboxRequestRegion: any;
+export type UpdateSandboxRequestFailoverRegionsItem = "iad1" | "sfo1" | "cle1" | "cdg1" | "fra1" | "arn1" | "sin1" | "pdx1" | "lhr1" | "icn1" | "bom1" | "cpt1" | "dub1" | "gru1" | "hkg1" | "syd1" | "yul1" | "hnd1" | "kix1";
+export declare const UpdateSandboxRequestFailoverRegionsItem: any;
+/** The regions the sandbox falls back to when it cannot be created in `region`. */
+export type UpdateSandboxRequestFailoverRegionsList = Array<UpdateSandboxRequestFailoverRegionsItem | (string & {})>;
+export declare const UpdateSandboxRequestFailoverRegionsList: S.Schema<UpdateSandboxRequestFailoverRegionsList>;
+/** 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?: CreateSandboxesByNameForkV2RequestResources;
+    /** 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;
+    /** The Vercel region in which to create the sandbox. */
+    region?: UpdateSandboxRequestRegion | (string & {});
+    /** The regions the sandbox falls back to when it cannot be created in `region`. */
+    failoverRegions?: UpdateSandboxRequestFailoverRegionsList;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** 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 = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringList>;
+/** Matcher for the entry key (header name or query key). */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+/** Matcher for the entry value. */
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+/** 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<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    /** 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 username, password, 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 CreateSandboxesByNameForkV2Error = 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 createSandboxesByNameForkV2: API.OperationMethod<CreateSandboxesByNameForkV2Request, CreateSandboxesByNameForkV2Response, CreateSandboxesByNameForkV2Error, VercelOpContext>;
+export type CreateSandboxesByNameForkV3Error = 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. Unlike v2, when neither the body nor the source provides a value, snapshots expire after 7 days by default and persistent sandboxes keep only their most recent snapshot (`keepLastSnapshots: null` disables the limit). */
+export declare const createSandboxesByNameForkV3: API.OperationMethod<CreateSandboxesByNameForkV3Request, CreateSandboxesByNameForkV3Response, CreateSandboxesByNameForkV3Error, VercelOpContext>;
+export type CreateSandboxesSessionsBySessionIdSnapshotV2Error = 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 createSandboxesSessionsBySessionIdSnapshotV2: API.OperationMethod<CreateSandboxesSessionsBySessionIdSnapshotV2Request, CreateSandboxesSessionsBySessionIdSnapshotV2Response, CreateSandboxesSessionsBySessionIdSnapshotV2Error, VercelOpContext>;
+export type CreateSandboxesSessionsBySessionIdSnapshotV3Error = 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. Unlike v2, snapshots expire after 7 days when neither the request nor the sandbox configuration specifies an expiration. */
+export declare const createSandboxesSessionsBySessionIdSnapshotV3: API.OperationMethod<CreateSandboxesSessionsBySessionIdSnapshotV3Request, CreateSandboxesSessionsBySessionIdSnapshotV3Response, CreateSandboxesSessionsBySessionIdSnapshotV3Error, 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 CreateSandboxesV4Error = 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. When no `image` is provided (and the sandbox is not restored from a snapshot), the sandbox is created from the default universal image. Unlike v3, snapshots expire after 7 days by default and persistent sandboxes keep only their most recent snapshot unless `keepLastSnapshots` is configured otherwise (or set to `null` to disable the limit). */
+export declare const createSandboxesV4: API.OperationMethod<CreateSandboxesV4Request, CreateSandboxesV4Response, CreateSandboxesV4Error, 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 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 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