@distilled.cloud/vercel 1.0.0-rc.7 → 1.0.0-rc.9

package/lib/services/sandboxes.d.ts

@@ -64,236 +64,244 @@ declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStr
 export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
 }
 /** The network access policy mode. Use \"allow-all\" to permit all outbound traffic. Use \"deny-all\" to block all outbound traffic. Use \"custom\" to specify explicit allow/deny rules. */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode = "allow-all" | "deny-all" | "custom" | "default-allow" | "default-deny";
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode: any;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
 /** Match on the request path. Comparison is case-sensitive. */
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath {
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** HTTP methods to match. Any single match succeeds (OR semantics). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchMethodList>;
 /** Matcher for the entry key (header name or query key). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem {
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    key?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
     /** Matcher for the entry value. */
-    value?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    value?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
 }
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList>;
 /** Matcher for the entry key (header name or query key). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch {
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch {
     /** Match on the request path. Comparison is case-sensitive. */
-    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
     /** HTTP methods to match. Any single match succeeds (OR semantics). */
-    method?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchMethodList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
+    headers?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersList;
 }
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem {
+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: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemHeadersMap;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatch;
+    match?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatch;
 }
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase0 {
+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: CreateSandboxesByNameForkRequestNetworkPolicyCase0Mode | (string & {});
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedDomainsList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0AllowedCIDRsList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0DeniedCIDRsList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesList;
+    injectionRules?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesList;
 }
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase0: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** HTTP methods to match. Any single match succeeds (OR semantics). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList = Array<string>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList>;
 /** Matcher for the entry key (header name or query key). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList = Array<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList>;
 /** Matcher for the entry key (header name or query key). */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch {
+export interface CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch {
     /** Match on the request path. Comparison is case-sensitive. */
-    path?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    path?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
     /** HTTP methods to match. Any single match succeeds (OR semantics). */
-    method?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchMethodList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringList;
+    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?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
+    headers?: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersList;
 }
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
+export declare const CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch>;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem {
-    headers?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItemHeadersMap;
-}
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem {
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemMatch;
-    transform?: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
-    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList = Array<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueItem>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList>;
+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 CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map = {
-    [key: string]: CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1ValueList | undefined;
+export type CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1Map = {
+    [key: string]: CreateSandboxesByNameForkV2RequestNetworkPolicyCase1AllowCase1ValueList | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow = CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase0List | CreateSandboxesByNameForkRequestNetworkPolicyCase1AllowCase1Map;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList>;
-export type CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList = Array<string>;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets {
-    allow?: CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsAllowList;
-    deny?: CreateSandboxesByNameForkRequestNetworkPolicyCase1SubnetsDenyList;
-}
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets>;
-export interface CreateSandboxesByNameForkRequestNetworkPolicyCase1 {
-    allow?: CreateSandboxesByNameForkRequestNetworkPolicyCase1Allow;
-    subnets?: CreateSandboxesByNameForkRequestNetworkPolicyCase1Subnets;
-}
-export declare const CreateSandboxesByNameForkRequestNetworkPolicyCase1: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase1>;
-export type CreateSandboxesByNameForkRequestNetworkPolicy = CreateSandboxesByNameForkRequestNetworkPolicyCase0 | CreateSandboxesByNameForkRequestNetworkPolicyCase1;
-export declare const CreateSandboxesByNameForkRequestNetworkPolicy: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicy>;
+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 CreateSandboxesByNameForkRequestResources {
+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 CreateSandboxesByNameForkRequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+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 CreateSandboxesByNameForkRequestPortsList = Array<number>;
-export declare const CreateSandboxesByNameForkRequestPortsList: S.Schema<CreateSandboxesByNameForkRequestPortsList>;
+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 CreateSandboxesByNameForkRequestEnvMap = {
+export type CreateSandboxesByNameForkV2RequestEnvMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestEnvMap: S.Schema<CreateSandboxesByNameForkRequestEnvMap>;
+export declare const CreateSandboxesByNameForkV2RequestEnvMap: S.Schema<CreateSandboxesByNameForkV2RequestEnvMap>;
 /** Mount the drive read-only or read-write. */
-export type CreateSandboxesByNameForkRequestMountsValueMode = "read-only" | "read-write";
-export declare const CreateSandboxesByNameForkRequestMountsValueMode: any;
-export interface CreateSandboxesByNameForkRequestMountsValue {
+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?: CreateSandboxesByNameForkRequestMountsValueMode | (string & {});
+    mode?: CreateSandboxesByNameForkV2RequestMountsValueMode | (string & {});
 }
-export declare const CreateSandboxesByNameForkRequestMountsValue: S.Schema<CreateSandboxesByNameForkRequestMountsValue>;
+export declare const CreateSandboxesByNameForkV2RequestMountsValue: S.Schema<CreateSandboxesByNameForkV2RequestMountsValue>;
 /** List of drives to mount to the sandbox at the provided path. */
-export type CreateSandboxesByNameForkRequestMountsMap = {
-    [key: string]: CreateSandboxesByNameForkRequestMountsValue | undefined;
+export type CreateSandboxesByNameForkV2RequestMountsMap = {
+    [key: string]: CreateSandboxesByNameForkV2RequestMountsValue | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestMountsMap: S.Schema<CreateSandboxesByNameForkRequestMountsMap>;
+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 CreateSandboxesByNameForkRequestSnapshotExpiration = unknown | number;
-export declare const CreateSandboxesByNameForkRequestSnapshotExpiration: S.Schema<CreateSandboxesByNameForkRequestSnapshotExpiration>;
+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 CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration = unknown | number;
-export declare const CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration: S.Schema<CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration>;
+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 CreateSandboxesByNameForkRequestKeepLastSnapshots {
+export interface CreateSandboxesByNameForkV2RequestKeepLastSnapshots {
     /** Number of most recent snapshots to keep. */
     count: number;
     /** Expiration time in milliseconds for kept snapshots. Falls back to snapshotExpiration. */
-    expiration?: CreateSandboxesByNameForkRequestKeepLastSnapshotsExpiration;
+    expiration?: CreateSandboxesByNameForkV2RequestKeepLastSnapshotsExpiration;
     /** Whether to immediately delete evicted snapshots. Defaults to true. */
     deleteEvicted?: boolean;
 }
-export declare const CreateSandboxesByNameForkRequestKeepLastSnapshots: S.Schema<CreateSandboxesByNameForkRequestKeepLastSnapshots>;
+export declare const CreateSandboxesByNameForkV2RequestKeepLastSnapshots: S.Schema<CreateSandboxesByNameForkV2RequestKeepLastSnapshots>;
 /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
-export type CreateSandboxesByNameForkRequestTagsMap = {
+export type CreateSandboxesByNameForkV2RequestTagsMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateSandboxesByNameForkRequestTagsMap: S.Schema<CreateSandboxesByNameForkRequestTagsMap>;
-export interface CreateSandboxesByNameForkRequest {
+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. */
@@ -302,32 +310,42 @@ export interface CreateSandboxesByNameForkRequest {
     teamId?: string;
     /** The Team slug to perform the request on behalf of. */
     slug?: string;
-    networkPolicy?: CreateSandboxesByNameForkRequestNetworkPolicy;
+    networkPolicy?: CreateSandboxesByNameForkV2RequestNetworkPolicy;
     /** Resources to define the VM */
-    resources?: CreateSandboxesByNameForkRequestResources;
+    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?: CreateSandboxesByNameForkRequestPortsList;
+    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?: CreateSandboxesByNameForkRequestEnvMap;
+    env?: CreateSandboxesByNameForkV2RequestEnvMap;
     /** List of drives to mount to the sandbox at the provided path. */
-    mounts?: CreateSandboxesByNameForkRequestMountsMap;
+    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?: CreateSandboxesByNameForkRequestSnapshotExpiration;
+    snapshotExpiration?: CreateSandboxesByNameForkV2RequestSnapshotExpiration;
     /** Protect the N most recent snapshots with different expiration/deletion behavior. */
-    keepLastSnapshots?: CreateSandboxesByNameForkRequestKeepLastSnapshots;
+    keepLastSnapshots?: CreateSandboxesByNameForkV2RequestKeepLastSnapshots;
     /** Key-value tags to associate with the sandbox. Maximum 5 tags. */
-    tags?: CreateSandboxesByNameForkRequestTagsMap;
+    tags?: CreateSandboxesByNameForkV2RequestTagsMap;
 }
-export declare const CreateSandboxesByNameForkRequest: S.Schema<CreateSandboxesByNameForkRequest>;
+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. */
@@ -352,6 +370,7 @@ export interface NamedSandboxNetworkPolicy {
     allowedDomains?: NamedSandboxNetworkPolicyAllowedDomainsList;
     allowedCIDRs?: NamedSandboxNetworkPolicyAllowedCIDRsList;
     deniedCIDRs?: NamedSandboxNetworkPolicyDeniedCIDRsList;
+    s3Key?: string;
 }
 export declare const NamedSandboxNetworkPolicy: S.Schema<NamedSandboxNetworkPolicy>;
 /** Key-value tags attached to the named sandbox. */
@@ -386,8 +405,10 @@ export interface NamedSandbox {
     statusUpdatedAt: number;
     /** Whether the sandbox persists its state across restarts via automatic snapshots. */
     persistent: boolean;
-    /** The region the sandbox is configured to run in: the region set on the sandbox, otherwise the project-level default, then the platform default. Where a running session actually landed is reported by `session.region`. */
+    /** 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. */
@@ -536,14 +557,358 @@ export interface SandboxPublicRoute {
     system?: boolean;
 }
 export declare const SandboxPublicRoute: S.Schema<SandboxPublicRoute>;
-export type CreateSandboxesByNameForkResponseRoutesList = Array<SandboxPublicRoute>;
-export declare const CreateSandboxesByNameForkResponseRoutesList: S.Schema<CreateSandboxesByNameForkResponseRoutesList>;
-export interface CreateSandboxesByNameForkResponse {
+export type CreateSandboxesByNameForkV2ResponseRoutesList = Array<SandboxPublicRoute>;
+export declare const CreateSandboxesByNameForkV2ResponseRoutesList: S.Schema<CreateSandboxesByNameForkV2ResponseRoutesList>;
+export interface CreateSandboxesByNameForkV2Response {
     sandbox: NamedSandbox;
     session: Session;
-    routes: CreateSandboxesByNameForkResponseRoutesList;
+    routes: CreateSandboxesByNameForkV2ResponseRoutesList;
 }
-export declare const CreateSandboxesByNameForkResponse: S.Schema<CreateSandboxesByNameForkResponse>;
+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;
@@ -562,37 +927,37 @@ export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersM
 };
 export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -630,37 +995,37 @@ export declare const CreateSandboxesV2RequestNetworkPolicyCase0: S.Schema<Create
 export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List = Array<string>;
 export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesV2RequestNetworkPolicyCase1AllowCase0List>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -683,7 +1048,7 @@ export interface CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItem {
     /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
     match?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
     transform?: CreateSandboxesV2RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
-    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    /** 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>;
@@ -716,8 +1081,8 @@ export declare const CreateSandboxesV2RequestNetworkPolicy: S.Schema<CreateSandb
 export type CreateSandboxesV2RequestRuntime = "node22" | "node24" | "node26" | "python3.13";
 export declare const CreateSandboxesV2RequestRuntime: any;
 /** Resources to define the VM */
-export type CreateSandboxesV2RequestResources = CreateSandboxesByNameForkRequestResources;
-export declare const CreateSandboxesV2RequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+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. */
@@ -776,6 +1141,14 @@ 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>;
@@ -806,7 +1179,7 @@ export interface CreateSandboxesV2Request {
     /** The runtime environment for the sandbox. Determines the pre-installed language runtimes and tools available. */
     runtime?: CreateSandboxesV2RequestRuntime | (string & {});
     /** Resources to define the VM */
-    resources?: CreateSandboxesByNameForkRequestResources;
+    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. */
@@ -821,6 +1194,10 @@ export interface CreateSandboxesV2Request {
     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. */
@@ -859,37 +1236,37 @@ export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersM
 };
 export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -927,37 +1304,37 @@ export declare const CreateSandboxesV3RequestNetworkPolicyCase0: S.Schema<Create
 export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List = Array<string>;
 export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List: S.Schema<CreateSandboxesV3RequestNetworkPolicyCase1AllowCase0List>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -980,7 +1357,7 @@ export interface CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItem {
     /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
     match?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemMatch;
     transform?: CreateSandboxesV3RequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
-    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    /** 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>;
@@ -1010,8 +1387,8 @@ export declare const CreateSandboxesV3RequestNetworkPolicyCase1: S.Schema<Create
 export type CreateSandboxesV3RequestNetworkPolicy = CreateSandboxesV3RequestNetworkPolicyCase0 | CreateSandboxesV3RequestNetworkPolicyCase1;
 export declare const CreateSandboxesV3RequestNetworkPolicy: S.Schema<CreateSandboxesV3RequestNetworkPolicy>;
 /** Resources to define the VM */
-export type CreateSandboxesV3RequestResources = CreateSandboxesByNameForkRequestResources;
-export declare const CreateSandboxesV3RequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+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>;
@@ -1047,6 +1424,14 @@ 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>;
@@ -1075,7 +1460,7 @@ export interface CreateSandboxesV3Request {
     slug?: string;
     networkPolicy?: CreateSandboxesV3RequestNetworkPolicy;
     /** Resources to define the VM */
-    resources?: CreateSandboxesByNameForkRequestResources;
+    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. */
@@ -1090,6 +1475,10 @@ export interface CreateSandboxesV3Request {
     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. */
@@ -1110,6 +1499,289 @@ export interface CreateSandboxesV3Response {
     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;
@@ -1127,57 +1799,6 @@ export interface CreateSessionDirectoryRequest {
 export declare const CreateSessionDirectoryRequest: S.Schema<CreateSessionDirectoryRequest>;
 export type CreateSessionDirectoryResponse = unknown;
 export declare const CreateSessionDirectoryResponse: S.Schema<CreateSessionDirectoryResponse>;
-/** The number of milliseconds after which the snapshot will expire and be deleted. Use 0 for no expiration. */
-export type CreateSessionSnapshotRequestExpiration = unknown | number;
-export declare const CreateSessionSnapshotRequestExpiration: S.Schema<CreateSessionSnapshotRequestExpiration>;
-export interface CreateSessionSnapshotRequest {
-    /** The unique identifier of the session to snapshot. */
-    sessionId: string;
-    /** The Team identifier to perform the request on behalf of. */
-    teamId?: string;
-    /** The Team slug to perform the request on behalf of. */
-    slug?: string;
-    /** The number of milliseconds after which the snapshot will expire and be deleted. Use 0 for no expiration. */
-    expiration?: CreateSessionSnapshotRequestExpiration;
-}
-export declare const CreateSessionSnapshotRequest: S.Schema<CreateSessionSnapshotRequest>;
-/** The status of the snapshot. */
-export type SnapshotStatus = "created" | "deleted" | "failed";
-export declare const SnapshotStatus: any;
-/** The method used to create the snapshot. */
-export type SnapshotCreationMethod = "automatic" | "manual";
-export declare const SnapshotCreationMethod: any;
-/** This object contains information related to a Snapshot of a Vercel Sandbox session (v2 API). */
-export interface Snapshot {
-    /** The unique identifier of the snapshot. */
-    id: string;
-    /** The unique identifier of the session from which the snapshot was created. */
-    sourceSessionId: string;
-    /** The region where the snapshot is stored. */
-    region?: string;
-    /** The status of the snapshot. */
-    status: SnapshotStatus;
-    /** The size of the snapshot in bytes. */
-    sizeBytes: number;
-    /** The time when the snapshot will expire, in milliseconds since the epoch. If not set, the snapshot does not have any expiration. */
-    expiresAt?: number;
-    /** The time when the snapshot was created, in milliseconds since the epoch. */
-    createdAt: number;
-    /** The last time the snapshot was updated, in milliseconds since the epoch. */
-    updatedAt: number;
-    /** The last time the snapshot was used (e.g. to resume or create a sandbox), in milliseconds since the epoch. Falls back to `createdAt` for older snapshots that predate this field. */
-    lastUsedAt: number;
-    /** The method used to create the snapshot. */
-    creationMethod?: SnapshotCreationMethod;
-    /** The unique identifier of the parent snapshot, if this snapshot was created from another snapshot. */
-    parentId?: string;
-}
-export declare const Snapshot: S.Schema<Snapshot>;
-export interface CreateSessionSnapshotResponse {
-    snapshot: Snapshot;
-    session: Session;
-}
-export declare const CreateSessionSnapshotResponse: S.Schema<CreateSessionSnapshotResponse>;
 export interface DeleteDriveRequest {
     /** Name for the drive. Must be unique per project and URL-safe (alphanumeric, hyphens, underscores). */
     name: string;
@@ -1191,6 +1812,8 @@ export interface DeleteDriveRequest {
 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. */
@@ -1218,6 +1841,8 @@ export interface DeleteSandboxRequest {
     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. */
@@ -1279,7 +1904,7 @@ export interface GetNamedSandboxResponse {
 }
 export declare const GetNamedSandboxResponse: S.Schema<GetNamedSandboxResponse>;
 /** Region where the drive is stored. Defaults to iad1. */
-export type GetOrCreateDriveRequestRegion = "iad1" | "sfo1" | "cle1";
+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). */
@@ -1440,52 +2065,6 @@ export interface ListDrivesResponse {
     pagination: ListDrivesResponsePagination;
 }
 export declare const ListDrivesResponse: S.Schema<ListDrivesResponse>;
-/** Field to sort by. */
-export type ListSandboxesRequestSortBy = "createdAt" | "name" | "statusUpdatedAt" | "currentSnapshotId";
-export declare const ListSandboxesRequestSortBy: any;
-/** Sort direction. Defaults to desc. */
-export type ListSandboxesRequestSortOrder = "asc" | "desc";
-export declare const ListSandboxesRequestSortOrder: any;
-/** Filter named sandboxes by status. Only valid when sortBy is createdAt. */
-export type ListSandboxesRequestStatus = "running" | "stopping" | "stopped";
-export declare const ListSandboxesRequestStatus: any;
-export type ListSandboxesRequestTagsCase1List = Array<string>;
-export declare const ListSandboxesRequestTagsCase1List: S.Schema<ListSandboxesRequestTagsCase1List>;
-/** Filter sandboxes by tag. Format: \"key:value\". Only one tag filter is supported at a time. */
-export type ListSandboxesRequestTags = string | ListSandboxesRequestTagsCase1List;
-export declare const ListSandboxesRequestTags: S.Schema<ListSandboxesRequestTags>;
-export interface ListSandboxesRequest {
-    /** The unique identifier or name of the project to list named sandboxes for. */
-    project?: string;
-    /** Maximum number of named sandboxes to return in the response. Used for pagination. */
-    limit?: number;
-    /** Field to sort by. */
-    sortBy?: ListSandboxesRequestSortBy | (string & {});
-    /** Filter named sandboxes whose name starts with this prefix. Only valid when sortBy=name. */
-    namePrefix?: string;
-    /** Opaque pagination cursor from a previous response. */
-    cursor?: string;
-    /** Sort direction. Defaults to desc. */
-    sortOrder?: ListSandboxesRequestSortOrder | (string & {});
-    /** Filter named sandboxes by status. Only valid when sortBy is createdAt. */
-    status?: ListSandboxesRequestStatus | (string & {});
-    /** Filter sandboxes by tag. Format: \"key:value\". Only one tag filter is supported at a time. */
-    tags?: ListSandboxesRequestTags;
-    /** The Team identifier to perform the request on behalf of. */
-    teamId?: string;
-    /** The Team slug to perform the request on behalf of. */
-    slug?: string;
-}
-export declare const ListSandboxesRequest: S.Schema<ListSandboxesRequest>;
-export type ListSandboxesResponseSandboxesList = Array<NamedSandbox>;
-export declare const ListSandboxesResponseSandboxesList: S.Schema<ListSandboxesResponseSandboxesList>;
-export type ListSandboxesResponsePagination = ListDrivesResponsePagination;
-export declare const ListSandboxesResponsePagination: S.Schema<ListDrivesResponsePagination>;
-export interface ListSandboxesResponse {
-    sandboxes: ListSandboxesResponseSandboxesList;
-    pagination: ListDrivesResponsePagination;
-}
-export declare const ListSandboxesResponse: S.Schema<ListSandboxesResponse>;
 export interface ListSessionCommandsRequest {
     /** The unique identifier of the session to list commands for. */
     sessionId: string;
@@ -1614,7 +2193,7 @@ export interface RunSessionCommandRequest {
     wait?: boolean;
     /** If true, stream the logs of the command execution in real-time via ND-JSON. This is only applicable if `wait` is also true. */
     logs?: boolean;
-    /** Maximum duration in milliseconds the command may run before it is killed with SIGKILL. Enforced at exec time, independently of `wait`. */
+    /** 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>;
@@ -1646,8 +2225,8 @@ export declare const StopSessionResponseBody: S.Schema<StopSessionResponseBody>;
 export type StopSessionResponse = StopSessionResponseBody;
 export declare const StopSessionResponse: S.Schema<StopSessionResponse>;
 /** Resources to define the VM */
-export type UpdateSandboxRequestResources = CreateSandboxesByNameForkRequestResources;
-export declare const UpdateSandboxRequestResources: S.Schema<CreateSandboxesByNameForkRequestResources>;
+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;
@@ -1687,37 +2266,37 @@ export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap =
 };
 export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap: S.Schema<UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemHeadersMap>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSandboxRequestNetworkPolicyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -1755,37 +2334,37 @@ export declare const UpdateSandboxRequestNetworkPolicyCase0: S.Schema<UpdateSand
 export type UpdateSandboxRequestNetworkPolicyCase1AllowCase0List = Array<string>;
 export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase0List: S.Schema<UpdateSandboxRequestNetworkPolicyCase1AllowCase0List>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -1808,7 +2387,7 @@ export interface UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItem {
     /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
     match?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemMatch;
     transform?: UpdateSandboxRequestNetworkPolicyCase1AllowCase1ValueItemTransformList;
-    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    /** 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>;
@@ -1837,6 +2416,14 @@ export interface UpdateSandboxRequestNetworkPolicyCase1 {
 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;
@@ -1862,7 +2449,7 @@ export interface UpdateSandboxRequest {
     /** The Team slug to perform the request on behalf of. */
     slug?: string;
     /** Resources to define the VM */
-    resources?: CreateSandboxesByNameForkRequestResources;
+    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. */
@@ -1874,6 +2461,10 @@ export interface UpdateSandboxRequest {
     /** 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. */
@@ -1922,37 +2513,37 @@ export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersM
 };
 export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemHeadersMap>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase0InjectionRulesItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -1990,37 +2581,37 @@ export declare const UpdateSessionNetworkPolicyRequestBodyCase0: S.Schema<Update
 export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List = Array<string>;
 export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List: S.Schema<UpdateSessionNetworkPolicyRequestBodyCase1AllowCase0List>;
 /** Match on the request path. Comparison is case-sensitive. */
-export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchPath = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchPath: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchQueryStringItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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 = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
+export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey = CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemKey: S.Schema<CreateSandboxesByNameForkV2RequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
 /** Matcher for the entry value. */
-export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItemValue: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath>;
-export type UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem = CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem;
-export declare const UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatchHeadersItem: S.Schema<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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<CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchQueryStringItem>;
+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?: CreateSandboxesByNameForkRequestNetworkPolicyCase0InjectionRulesItemMatchPath;
+    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. */
@@ -2043,7 +2634,7 @@ export interface UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItem {
     /** Optional L7 match. When provided, the injection rule only applies to requests that satisfy every specified dimension. When multiple injection rules target the same domain they are evaluated in order and the first match wins; a rule without `match` matches any request and shadows later rules for the same domain. */
     match?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemMatch;
     transform?: UpdateSessionNetworkPolicyRequestBodyCase1AllowCase1ValueItemTransformList;
-    /** HTTP/1.1 proxy URL to forward traffic to. Must not include query string or fragment. */
+    /** 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>;
@@ -2099,21 +2690,30 @@ export interface WriteSessionFilesRequest {
 export declare const WriteSessionFilesRequest: S.Schema<WriteSessionFilesRequest>;
 export type WriteSessionFilesResponse = unknown;
 export declare const WriteSessionFilesResponse: S.Schema<WriteSessionFilesResponse>;
-export type CreateSandboxesByNameForkError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+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 createSandboxesByNameFork: API.OperationMethod<CreateSandboxesByNameForkRequest, CreateSandboxesByNameForkResponse, CreateSandboxesByNameForkError, VercelOpContext>;
+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 CreateSessionSnapshotError = BadRequest | PaymentRequired | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
-/** Create a snapshot Creates a point-in-time snapshot of a running session's filesystem. Snapshots can be used to quickly restore a session to a previous state or to create new sessions with pre-configured environments. The session must be running and able to accept commands for a snapshot to be created. The session will be terminated after the snapshot is created. */
-export declare const createSessionSnapshot: API.OperationMethod<CreateSessionSnapshotRequest, CreateSessionSnapshotResponse, CreateSessionSnapshotError, VercelOpContext>;
 export type DeleteDriveError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
 /** Delete a drive Deletes a drive by project and name. Attached drives cannot be deleted. Stop or replace the session currently using the drive before retrying deletion. Drives are in private beta. Register your interest to get access: https://vercel.com/changelog/drives-for-vercel-sandbox-in-private-beta */
 export declare const deleteDrive: API.OperationMethod<DeleteDriveRequest, DeleteDriveResponse, DeleteDriveError, VercelOpContext>;
@@ -2150,9 +2750,6 @@ export declare const killSessionCommand: API.OperationMethod<KillSessionCommandR
 export type ListDrivesError = BadRequest | Forbidden | NotFound | VercelOpError;
 /** List drives Retrieves a paginated list of drives belonging to a specific project. Drives are in private beta. Register your interest to get access: https://vercel.com/changelog/drives-for-vercel-sandbox-in-private-beta */
 export declare const listDrives: API.OperationMethod<ListDrivesRequest, ListDrivesResponse, ListDrivesError, VercelOpContext>;
-export type ListSandboxesError = BadRequest | Forbidden | NotFound | VercelOpError;
-/** List sandboxes Retrieves a paginated list of named sandboxes belonging to a specific project. Results can be sorted by creation time or name, and optionally filtered by name prefix or status. */
-export declare const listSandboxes: API.OperationMethod<ListSandboxesRequest, ListSandboxesResponse, ListSandboxesError, VercelOpContext>;
 export type ListSessionCommandsError = BadRequest | Forbidden | NotFound | VercelOpError;
 /** List commands Retrieves a list of all commands that have been executed in a session, including their current status, exit codes, and execution times, ordered from the most recent to the oldest. */
 export declare const listSessionCommands: API.OperationMethod<ListSessionCommandsRequest, ListSessionCommandsResponse, ListSessionCommandsError, VercelOpContext>;