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

package/lib/services/project_routes.d.ts

@@ -0,0 +1,1990 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type VercelOpError, type VercelOpContext } from "../protocol.ts";
+export type { VercelOpError, VercelOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+/** Pattern syntax type. If not provided, inferred from pattern. */
+export type AddRouteRequestRouteSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const AddRouteRequestRouteSrcSyntax: any;
+export type AddRouteRequestRouteRouteHasItemType = "host" | "header" | "cookie" | "query";
+export declare const AddRouteRequestRouteRouteHasItemType: any;
+export interface AddRouteRequestRouteRouteHasItem {
+    type?: AddRouteRequestRouteRouteHasItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const AddRouteRequestRouteRouteHasItem: S.Schema<AddRouteRequestRouteRouteHasItem>;
+export type AddRouteRequestRouteRouteHasList = Array<AddRouteRequestRouteRouteHasItem>;
+export declare const AddRouteRequestRouteRouteHasList: S.Schema<AddRouteRequestRouteRouteHasList>;
+export type AddRouteRequestRouteRouteMissingItemType = "host" | "header" | "cookie" | "query";
+export declare const AddRouteRequestRouteRouteMissingItemType: any;
+export interface AddRouteRequestRouteRouteMissingItem {
+    type?: AddRouteRequestRouteRouteMissingItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const AddRouteRequestRouteRouteMissingItem: S.Schema<AddRouteRequestRouteRouteMissingItem>;
+export type AddRouteRequestRouteRouteMissingList = Array<AddRouteRequestRouteRouteMissingItem>;
+export declare const AddRouteRequestRouteRouteMissingList: S.Schema<AddRouteRequestRouteRouteMissingList>;
+export type AddRouteRequestRouteRouteTransformsItemType = "request.headers" | "request.query" | "response.headers";
+export declare const AddRouteRequestRouteRouteTransformsItemType: any;
+export type AddRouteRequestRouteRouteTransformsItemOp = "append" | "set" | "delete";
+export declare const AddRouteRequestRouteRouteTransformsItemOp: any;
+export type AddRouteRequestRouteRouteTransformsItemEnvList = Array<string>;
+export declare const AddRouteRequestRouteRouteTransformsItemEnvList: S.Schema<AddRouteRequestRouteRouteTransformsItemEnvList>;
+export interface AddRouteRequestRouteRouteTransformsItem {
+    type?: AddRouteRequestRouteRouteTransformsItemType | (string & {});
+    op?: AddRouteRequestRouteRouteTransformsItemOp | (string & {});
+    target?: unknown;
+    args?: unknown;
+    env?: AddRouteRequestRouteRouteTransformsItemEnvList;
+}
+export declare const AddRouteRequestRouteRouteTransformsItem: S.Schema<AddRouteRequestRouteRouteTransformsItem>;
+export type AddRouteRequestRouteRouteTransformsList = Array<AddRouteRequestRouteRouteTransformsItem>;
+export declare const AddRouteRequestRouteRouteTransformsList: S.Schema<AddRouteRequestRouteRouteTransformsList>;
+export interface AddRouteRequestRouteRoute {
+    src: string;
+    dest?: string;
+    headers?: unknown;
+    caseSensitive?: boolean;
+    status?: number;
+    has?: AddRouteRequestRouteRouteHasList;
+    missing?: AddRouteRequestRouteRouteMissingList;
+    transforms?: AddRouteRequestRouteRouteTransformsList;
+    respectOriginCacheControl?: boolean;
+}
+export declare const AddRouteRequestRouteRoute: S.Schema<AddRouteRequestRouteRoute>;
+export interface AddRouteRequestRoute {
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    /** Pattern syntax type. If not provided, inferred from pattern. */
+    srcSyntax?: AddRouteRequestRouteSrcSyntax | (string & {});
+    route: AddRouteRequestRouteRoute;
+}
+export declare const AddRouteRequestRoute: S.Schema<AddRouteRequestRoute>;
+/** "after"/"before" require referenceId. */
+export type AddRouteRequestPositionPlacement = "start" | "end" | "after" | "before";
+export declare const AddRouteRequestPositionPlacement: any;
+/** Controls where the route is inserted. Defaults to "end" if omitted. */
+export interface AddRouteRequestPosition {
+    /** "after"/"before" require referenceId. */
+    placement?: AddRouteRequestPositionPlacement | (string & {});
+    /** Route ID to insert after/before. Required for "after"/"before". */
+    referenceId?: string;
+}
+export declare const AddRouteRequestPosition: S.Schema<AddRouteRequestPosition>;
+export interface AddRouteRequest {
+    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;
+    route: AddRouteRequestRoute;
+    /** Controls where the route is inserted. Defaults to "end" if omitted. */
+    position?: AddRouteRequestPosition;
+}
+export declare const AddRouteRequest: S.Schema<AddRouteRequest>;
+export type AddRouteResponseRouteRouteType = "redirect" | "rewrite" | "set_status" | "transform";
+export declare const AddRouteResponseRouteRouteType: any;
+export type AddRouteResponseRouteRouteHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const AddRouteResponseRouteRouteHeadersMap: S.Schema<AddRouteResponseRouteRouteHeadersMap>;
+export type AddRouteResponseRouteRouteMethodsList = Array<string>;
+export declare const AddRouteResponseRouteRouteMethodsList: S.Schema<AddRouteResponseRouteRouteMethodsList>;
+export type AddRouteResponseRouteRouteHasItemCase0Type = "host";
+export declare const AddRouteResponseRouteRouteHasItemCase0Type: any;
+export type AddRouteResponseRouteRouteHasItemCase0ValueCase1Eq = string | number;
+export declare const AddRouteResponseRouteRouteHasItemCase0ValueCase1Eq: S.Schema<AddRouteResponseRouteRouteHasItemCase0ValueCase1Eq>;
+export type AddRouteResponseRouteRouteHasItemCase0ValueCase1IncList = Array<string>;
+export declare const AddRouteResponseRouteRouteHasItemCase0ValueCase1IncList: S.Schema<AddRouteResponseRouteRouteHasItemCase0ValueCase1IncList>;
+export type AddRouteResponseRouteRouteHasItemCase0ValueCase1NincList = Array<string>;
+export declare const AddRouteResponseRouteRouteHasItemCase0ValueCase1NincList: S.Schema<AddRouteResponseRouteRouteHasItemCase0ValueCase1NincList>;
+export interface AddRouteResponseRouteRouteHasItemCase0ValueCase1 {
+    eq?: AddRouteResponseRouteRouteHasItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: AddRouteResponseRouteRouteHasItemCase0ValueCase1IncList;
+    ninc?: AddRouteResponseRouteRouteHasItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const AddRouteResponseRouteRouteHasItemCase0ValueCase1: S.Schema<AddRouteResponseRouteRouteHasItemCase0ValueCase1>;
+export type AddRouteResponseRouteRouteHasItemCase0Value = string | AddRouteResponseRouteRouteHasItemCase0ValueCase1;
+export declare const AddRouteResponseRouteRouteHasItemCase0Value: S.Schema<AddRouteResponseRouteRouteHasItemCase0Value>;
+export interface AddRouteResponseRouteRouteHasItemCase0 {
+    type: AddRouteResponseRouteRouteHasItemCase0Type;
+    value: AddRouteResponseRouteRouteHasItemCase0Value;
+}
+export declare const AddRouteResponseRouteRouteHasItemCase0: S.Schema<AddRouteResponseRouteRouteHasItemCase0>;
+export type AddRouteResponseRouteRouteHasItemCase1Type = "cookie" | "header" | "query";
+export declare const AddRouteResponseRouteRouteHasItemCase1Type: any;
+export type AddRouteResponseRouteRouteHasItemCase1ValueCase1Eq = string | number;
+export declare const AddRouteResponseRouteRouteHasItemCase1ValueCase1Eq: S.Schema<AddRouteResponseRouteRouteHasItemCase1ValueCase1Eq>;
+export type AddRouteResponseRouteRouteHasItemCase1ValueCase1IncList = Array<string>;
+export declare const AddRouteResponseRouteRouteHasItemCase1ValueCase1IncList: S.Schema<AddRouteResponseRouteRouteHasItemCase1ValueCase1IncList>;
+export type AddRouteResponseRouteRouteHasItemCase1ValueCase1NincList = Array<string>;
+export declare const AddRouteResponseRouteRouteHasItemCase1ValueCase1NincList: S.Schema<AddRouteResponseRouteRouteHasItemCase1ValueCase1NincList>;
+export interface AddRouteResponseRouteRouteHasItemCase1ValueCase1 {
+    eq?: AddRouteResponseRouteRouteHasItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: AddRouteResponseRouteRouteHasItemCase1ValueCase1IncList;
+    ninc?: AddRouteResponseRouteRouteHasItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const AddRouteResponseRouteRouteHasItemCase1ValueCase1: S.Schema<AddRouteResponseRouteRouteHasItemCase1ValueCase1>;
+export type AddRouteResponseRouteRouteHasItemCase1Value = string | AddRouteResponseRouteRouteHasItemCase1ValueCase1;
+export declare const AddRouteResponseRouteRouteHasItemCase1Value: S.Schema<AddRouteResponseRouteRouteHasItemCase1Value>;
+export interface AddRouteResponseRouteRouteHasItemCase1 {
+    type: AddRouteResponseRouteRouteHasItemCase1Type;
+    key: string;
+    value?: AddRouteResponseRouteRouteHasItemCase1Value;
+}
+export declare const AddRouteResponseRouteRouteHasItemCase1: S.Schema<AddRouteResponseRouteRouteHasItemCase1>;
+export type AddRouteResponseRouteRouteHasItem = AddRouteResponseRouteRouteHasItemCase0 | AddRouteResponseRouteRouteHasItemCase1;
+export declare const AddRouteResponseRouteRouteHasItem: S.Schema<AddRouteResponseRouteRouteHasItem>;
+export type AddRouteResponseRouteRouteHasList = Array<AddRouteResponseRouteRouteHasItem>;
+export declare const AddRouteResponseRouteRouteHasList: S.Schema<AddRouteResponseRouteRouteHasList>;
+export type AddRouteResponseRouteRouteMissingItemCase0Type = "host";
+export declare const AddRouteResponseRouteRouteMissingItemCase0Type: any;
+export type AddRouteResponseRouteRouteMissingItemCase0ValueCase1Eq = string | number;
+export declare const AddRouteResponseRouteRouteMissingItemCase0ValueCase1Eq: S.Schema<AddRouteResponseRouteRouteMissingItemCase0ValueCase1Eq>;
+export type AddRouteResponseRouteRouteMissingItemCase0ValueCase1IncList = Array<string>;
+export declare const AddRouteResponseRouteRouteMissingItemCase0ValueCase1IncList: S.Schema<AddRouteResponseRouteRouteMissingItemCase0ValueCase1IncList>;
+export type AddRouteResponseRouteRouteMissingItemCase0ValueCase1NincList = Array<string>;
+export declare const AddRouteResponseRouteRouteMissingItemCase0ValueCase1NincList: S.Schema<AddRouteResponseRouteRouteMissingItemCase0ValueCase1NincList>;
+export interface AddRouteResponseRouteRouteMissingItemCase0ValueCase1 {
+    eq?: AddRouteResponseRouteRouteMissingItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: AddRouteResponseRouteRouteMissingItemCase0ValueCase1IncList;
+    ninc?: AddRouteResponseRouteRouteMissingItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const AddRouteResponseRouteRouteMissingItemCase0ValueCase1: S.Schema<AddRouteResponseRouteRouteMissingItemCase0ValueCase1>;
+export type AddRouteResponseRouteRouteMissingItemCase0Value = string | AddRouteResponseRouteRouteMissingItemCase0ValueCase1;
+export declare const AddRouteResponseRouteRouteMissingItemCase0Value: S.Schema<AddRouteResponseRouteRouteMissingItemCase0Value>;
+export interface AddRouteResponseRouteRouteMissingItemCase0 {
+    type: AddRouteResponseRouteRouteMissingItemCase0Type;
+    value: AddRouteResponseRouteRouteMissingItemCase0Value;
+}
+export declare const AddRouteResponseRouteRouteMissingItemCase0: S.Schema<AddRouteResponseRouteRouteMissingItemCase0>;
+export type AddRouteResponseRouteRouteMissingItemCase1Type = "cookie" | "header" | "query";
+export declare const AddRouteResponseRouteRouteMissingItemCase1Type: any;
+export type AddRouteResponseRouteRouteMissingItemCase1ValueCase1Eq = string | number;
+export declare const AddRouteResponseRouteRouteMissingItemCase1ValueCase1Eq: S.Schema<AddRouteResponseRouteRouteMissingItemCase1ValueCase1Eq>;
+export type AddRouteResponseRouteRouteMissingItemCase1ValueCase1IncList = Array<string>;
+export declare const AddRouteResponseRouteRouteMissingItemCase1ValueCase1IncList: S.Schema<AddRouteResponseRouteRouteMissingItemCase1ValueCase1IncList>;
+export type AddRouteResponseRouteRouteMissingItemCase1ValueCase1NincList = Array<string>;
+export declare const AddRouteResponseRouteRouteMissingItemCase1ValueCase1NincList: S.Schema<AddRouteResponseRouteRouteMissingItemCase1ValueCase1NincList>;
+export interface AddRouteResponseRouteRouteMissingItemCase1ValueCase1 {
+    eq?: AddRouteResponseRouteRouteMissingItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: AddRouteResponseRouteRouteMissingItemCase1ValueCase1IncList;
+    ninc?: AddRouteResponseRouteRouteMissingItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const AddRouteResponseRouteRouteMissingItemCase1ValueCase1: S.Schema<AddRouteResponseRouteRouteMissingItemCase1ValueCase1>;
+export type AddRouteResponseRouteRouteMissingItemCase1Value = string | AddRouteResponseRouteRouteMissingItemCase1ValueCase1;
+export declare const AddRouteResponseRouteRouteMissingItemCase1Value: S.Schema<AddRouteResponseRouteRouteMissingItemCase1Value>;
+export interface AddRouteResponseRouteRouteMissingItemCase1 {
+    type: AddRouteResponseRouteRouteMissingItemCase1Type;
+    key: string;
+    value?: AddRouteResponseRouteRouteMissingItemCase1Value;
+}
+export declare const AddRouteResponseRouteRouteMissingItemCase1: S.Schema<AddRouteResponseRouteRouteMissingItemCase1>;
+export type AddRouteResponseRouteRouteMissingItem = AddRouteResponseRouteRouteMissingItemCase0 | AddRouteResponseRouteRouteMissingItemCase1;
+export declare const AddRouteResponseRouteRouteMissingItem: S.Schema<AddRouteResponseRouteRouteMissingItem>;
+export type AddRouteResponseRouteRouteMissingList = Array<AddRouteResponseRouteRouteMissingItem>;
+export declare const AddRouteResponseRouteRouteMissingList: S.Schema<AddRouteResponseRouteRouteMissingList>;
+export type AddRouteResponseRouteRouteMitigateAction = "challenge" | "deny";
+export declare const AddRouteResponseRouteRouteMitigateAction: any;
+export interface AddRouteResponseRouteRouteMitigate {
+    action: AddRouteResponseRouteRouteMitigateAction;
+}
+export declare const AddRouteResponseRouteRouteMitigate: S.Schema<AddRouteResponseRouteRouteMitigate>;
+export type AddRouteResponseRouteRouteTransformsItemCase0Type = "request.headers" | "request.query" | "response.headers";
+export declare const AddRouteResponseRouteRouteTransformsItemCase0Type: any;
+export type AddRouteResponseRouteRouteTransformsItemCase0Op = "append" | "delete" | "set";
+export declare const AddRouteResponseRouteRouteTransformsItemCase0Op: any;
+export type AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq = string | number;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq>;
+export type AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList = Array<string>;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList>;
+export type AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList = Array<string>;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList>;
+export interface AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1 {
+    eq?: AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq;
+    neq?: string;
+    inc?: AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList;
+    ninc?: AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList;
+    pre?: string;
+    suf?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1>;
+export type AddRouteResponseRouteRouteTransformsItemCase0TargetKey = string | AddRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0TargetKey: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0TargetKey>;
+export interface AddRouteResponseRouteRouteTransformsItemCase0Target {
+    key: AddRouteResponseRouteRouteTransformsItemCase0TargetKey;
+}
+export declare const AddRouteResponseRouteRouteTransformsItemCase0Target: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0Target>;
+export type AddRouteResponseRouteRouteTransformsItemCase0ArgsCase1List = Array<string>;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0ArgsCase1List: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0ArgsCase1List>;
+export type AddRouteResponseRouteRouteTransformsItemCase0Args = string | AddRouteResponseRouteRouteTransformsItemCase0ArgsCase1List;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0Args: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0Args>;
+export type AddRouteResponseRouteRouteTransformsItemCase0EnvList = Array<string>;
+export declare const AddRouteResponseRouteRouteTransformsItemCase0EnvList: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0EnvList>;
+export interface AddRouteResponseRouteRouteTransformsItemCase0 {
+    type: AddRouteResponseRouteRouteTransformsItemCase0Type;
+    op: AddRouteResponseRouteRouteTransformsItemCase0Op;
+    target: AddRouteResponseRouteRouteTransformsItemCase0Target;
+    args?: AddRouteResponseRouteRouteTransformsItemCase0Args;
+    env?: AddRouteResponseRouteRouteTransformsItemCase0EnvList;
+}
+export declare const AddRouteResponseRouteRouteTransformsItemCase0: S.Schema<AddRouteResponseRouteRouteTransformsItemCase0>;
+export type AddRouteResponseRouteRouteTransformsItemCase1Type = "request.path";
+export declare const AddRouteResponseRouteRouteTransformsItemCase1Type: any;
+export type AddRouteResponseRouteRouteTransformsItemCase1Op = "set";
+export declare const AddRouteResponseRouteRouteTransformsItemCase1Op: any;
+export type AddRouteResponseRouteRouteTransformsItemCase1EnvList = Array<string>;
+export declare const AddRouteResponseRouteRouteTransformsItemCase1EnvList: S.Schema<AddRouteResponseRouteRouteTransformsItemCase1EnvList>;
+export interface AddRouteResponseRouteRouteTransformsItemCase1 {
+    type: AddRouteResponseRouteRouteTransformsItemCase1Type;
+    op: AddRouteResponseRouteRouteTransformsItemCase1Op;
+    args: string;
+    env?: AddRouteResponseRouteRouteTransformsItemCase1EnvList;
+}
+export declare const AddRouteResponseRouteRouteTransformsItemCase1: S.Schema<AddRouteResponseRouteRouteTransformsItemCase1>;
+export type AddRouteResponseRouteRouteTransformsItem = AddRouteResponseRouteRouteTransformsItemCase0 | AddRouteResponseRouteRouteTransformsItemCase1;
+export declare const AddRouteResponseRouteRouteTransformsItem: S.Schema<AddRouteResponseRouteRouteTransformsItem>;
+export type AddRouteResponseRouteRouteTransformsList = Array<AddRouteResponseRouteRouteTransformsItem>;
+export declare const AddRouteResponseRouteRouteTransformsList: S.Schema<AddRouteResponseRouteRouteTransformsList>;
+export type AddRouteResponseRouteRouteEnvList = Array<string>;
+export declare const AddRouteResponseRouteRouteEnvList: S.Schema<AddRouteResponseRouteRouteEnvList>;
+export type AddRouteResponseRouteRouteLocaleRedirectMap = {
+    [key: string]: string | undefined;
+};
+export declare const AddRouteResponseRouteRouteLocaleRedirectMap: S.Schema<AddRouteResponseRouteRouteLocaleRedirectMap>;
+export interface AddRouteResponseRouteRouteLocale {
+    redirect?: AddRouteResponseRouteRouteLocaleRedirectMap;
+    cookie?: string;
+}
+export declare const AddRouteResponseRouteRouteLocale: S.Schema<AddRouteResponseRouteRouteLocale>;
+/** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+export type AddRouteResponseRouteRouteDestinationCase1Type = "service";
+export declare const AddRouteResponseRouteRouteDestinationCase1Type: any;
+export interface AddRouteResponseRouteRouteDestinationCase1 {
+    /** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+    type?: AddRouteResponseRouteRouteDestinationCase1Type;
+    service: string;
+    /** Routing-only path used to select a route inside the target service. */
+    path?: string;
+}
+export declare const AddRouteResponseRouteRouteDestinationCase1: S.Schema<AddRouteResponseRouteRouteDestinationCase1>;
+export type AddRouteResponseRouteRouteDestination = string | AddRouteResponseRouteRouteDestinationCase1;
+export declare const AddRouteResponseRouteRouteDestination: S.Schema<AddRouteResponseRouteRouteDestination>;
+/** The original middleware matchers. */
+export type AddRouteResponseRouteRouteMiddlewareRawSrcList = Array<string>;
+export declare const AddRouteResponseRouteRouteMiddlewareRawSrcList: S.Schema<AddRouteResponseRouteRouteMiddlewareRawSrcList>;
+/** The route definition from @vercel/routing-utils. */
+export interface AddRouteResponseRouteRoute {
+    src: string;
+    dest?: string;
+    headers?: AddRouteResponseRouteRouteHeadersMap;
+    methods?: AddRouteResponseRouteRouteMethodsList;
+    continue?: boolean;
+    override?: boolean;
+    caseSensitive?: boolean;
+    check?: boolean;
+    important?: boolean;
+    status?: number;
+    has?: AddRouteResponseRouteRouteHasList;
+    missing?: AddRouteResponseRouteRouteMissingList;
+    mitigate?: AddRouteResponseRouteRouteMitigate;
+    transforms?: AddRouteResponseRouteRouteTransformsList;
+    env?: AddRouteResponseRouteRouteEnvList;
+    locale?: AddRouteResponseRouteRouteLocale;
+    /** Aliases for `src`, `dest`, and `status`. These provide consistency with the `rewrites`, `redirects`, and `headers` fields which use `source`, `destination`, and `statusCode`. During normalization, the string forms are converted to their canonical forms (`src`, `dest`, `status`) and stripped from the route object. `destination` may also be a service-targeted object, in which case routing is delegated into the named service's internal route table and the object is preserved as-is (not folded into `dest`). */
+    source?: string;
+    destination?: AddRouteResponseRouteRouteDestination;
+    statusCode?: number;
+    /** A middleware key within the `output` key under the build result. Overrides a `middleware` definition. */
+    middlewarePath?: string;
+    /** The original middleware matchers. */
+    middlewareRawSrc?: AddRouteResponseRouteRouteMiddlewareRawSrcList;
+    /** A middleware index in the `middleware` key under the build result */
+    middleware?: number;
+    respectOriginCacheControl?: boolean;
+}
+export declare const AddRouteResponseRouteRoute: S.Schema<AddRouteResponseRouteRoute>;
+/** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+export type AddRouteResponseRouteSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const AddRouteResponseRouteSrcSyntax: any;
+export interface AddRouteResponseRoute {
+    routeType?: AddRouteResponseRouteRouteType;
+    /** Unique identifier for the routing rule. */
+    id: string;
+    /** Human-readable name for the routing rule. */
+    name: string;
+    /** Optional description of what the routing rule does. */
+    description?: string;
+    /** Whether the routing rule is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Whether this route is new and not yet published to production. Set to true only when a route is first created via add-route. Cleared (set to false) when a version is promoted to production. */
+    staged?: boolean;
+    /** The route definition from @vercel/routing-utils. */
+    route: AddRouteResponseRouteRoute;
+    /** Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses. */
+    rawSrc?: string;
+    /** Original destination provided by user. */
+    rawDest?: string;
+    /** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+    srcSyntax?: AddRouteResponseRouteSrcSyntax;
+}
+export declare const AddRouteResponseRoute: S.Schema<AddRouteResponseRoute>;
+/** A version of routing rules stored in S3. */
+export interface AddRouteResponseVersion {
+    /** Unique identifier for the version. */
+    id: string;
+    /** The S3 key where the routing rules are stored. */
+    s3Key: string;
+    /** Timestamp of when this version was last modified. */
+    lastModified: number;
+    /** The user who created this version. */
+    createdBy: string;
+    /** Whether this version is staged and not yet promoted to production. */
+    isStaging?: boolean;
+    /** Whether this version is currently live in production. */
+    isLive?: boolean;
+    /** The number of routing rules in this version. */
+    ruleCount?: number;
+    /** The staging alias for previewing this version. */
+    alias?: string;
+}
+export declare const AddRouteResponseVersion: S.Schema<AddRouteResponseVersion>;
+export interface AddRouteResponse {
+    route: AddRouteResponseRoute;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const AddRouteResponse: S.Schema<AddRouteResponse>;
+/** The IDs of the routes to delete */
+export type DeleteRoutesRequestRouteIdsList = Array<string>;
+export declare const DeleteRoutesRequestRouteIdsList: S.Schema<DeleteRoutesRequestRouteIdsList>;
+export interface DeleteRoutesRequest {
+    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;
+    /** The IDs of the routes to delete */
+    routeIds: DeleteRoutesRequestRouteIdsList;
+}
+export declare const DeleteRoutesRequest: S.Schema<DeleteRoutesRequest>;
+/** A version of routing rules stored in S3. */
+export type DeleteRoutesResponseVersion = AddRouteResponseVersion;
+export declare const DeleteRoutesResponseVersion: S.Schema<AddRouteResponseVersion>;
+export interface DeleteRoutesResponse {
+    deletedCount: number;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const DeleteRoutesResponse: S.Schema<DeleteRoutesResponse>;
+/** Pattern syntax type. If not provided, inferred from pattern. */
+export type EditRouteRequestRouteSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const EditRouteRequestRouteSrcSyntax: any;
+export type EditRouteRequestRouteRouteHasItemType = "host" | "header" | "cookie" | "query";
+export declare const EditRouteRequestRouteRouteHasItemType: any;
+export interface EditRouteRequestRouteRouteHasItem {
+    type?: EditRouteRequestRouteRouteHasItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const EditRouteRequestRouteRouteHasItem: S.Schema<EditRouteRequestRouteRouteHasItem>;
+export type EditRouteRequestRouteRouteHasList = Array<EditRouteRequestRouteRouteHasItem>;
+export declare const EditRouteRequestRouteRouteHasList: S.Schema<EditRouteRequestRouteRouteHasList>;
+export type EditRouteRequestRouteRouteMissingItemType = "host" | "header" | "cookie" | "query";
+export declare const EditRouteRequestRouteRouteMissingItemType: any;
+export interface EditRouteRequestRouteRouteMissingItem {
+    type?: EditRouteRequestRouteRouteMissingItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const EditRouteRequestRouteRouteMissingItem: S.Schema<EditRouteRequestRouteRouteMissingItem>;
+export type EditRouteRequestRouteRouteMissingList = Array<EditRouteRequestRouteRouteMissingItem>;
+export declare const EditRouteRequestRouteRouteMissingList: S.Schema<EditRouteRequestRouteRouteMissingList>;
+export type EditRouteRequestRouteRouteTransformsItemType = "request.headers" | "request.query" | "response.headers";
+export declare const EditRouteRequestRouteRouteTransformsItemType: any;
+export type EditRouteRequestRouteRouteTransformsItemOp = "append" | "set" | "delete";
+export declare const EditRouteRequestRouteRouteTransformsItemOp: any;
+export type EditRouteRequestRouteRouteTransformsItemEnvList = Array<string>;
+export declare const EditRouteRequestRouteRouteTransformsItemEnvList: S.Schema<EditRouteRequestRouteRouteTransformsItemEnvList>;
+export interface EditRouteRequestRouteRouteTransformsItem {
+    type?: EditRouteRequestRouteRouteTransformsItemType | (string & {});
+    op?: EditRouteRequestRouteRouteTransformsItemOp | (string & {});
+    target?: unknown;
+    args?: unknown;
+    env?: EditRouteRequestRouteRouteTransformsItemEnvList;
+}
+export declare const EditRouteRequestRouteRouteTransformsItem: S.Schema<EditRouteRequestRouteRouteTransformsItem>;
+export type EditRouteRequestRouteRouteTransformsList = Array<EditRouteRequestRouteRouteTransformsItem>;
+export declare const EditRouteRequestRouteRouteTransformsList: S.Schema<EditRouteRequestRouteRouteTransformsList>;
+export interface EditRouteRequestRouteRoute {
+    src: string;
+    dest?: string;
+    headers?: unknown;
+    caseSensitive?: boolean;
+    status?: number;
+    has?: EditRouteRequestRouteRouteHasList;
+    missing?: EditRouteRequestRouteRouteMissingList;
+    transforms?: EditRouteRequestRouteRouteTransformsList;
+    respectOriginCacheControl?: boolean;
+}
+export declare const EditRouteRequestRouteRoute: S.Schema<EditRouteRequestRouteRoute>;
+/** The full route object to replace the existing route with */
+export interface EditRouteRequestRoute {
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    /** Pattern syntax type. If not provided, inferred from pattern. */
+    srcSyntax?: EditRouteRequestRouteSrcSyntax | (string & {});
+    route: EditRouteRequestRouteRoute;
+}
+export declare const EditRouteRequestRoute: S.Schema<EditRouteRequestRoute>;
+export interface EditRouteRequest {
+    projectId: string;
+    routeId: 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 full route object to replace the existing route with */
+    route?: EditRouteRequestRoute;
+    /** If true, restores the staged route to the value in the production version. */
+    restore?: boolean;
+}
+export declare const EditRouteRequest: S.Schema<EditRouteRequest>;
+export type EditRouteResponseRouteRouteType = "redirect" | "rewrite" | "set_status" | "transform";
+export declare const EditRouteResponseRouteRouteType: any;
+export type EditRouteResponseRouteRouteHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const EditRouteResponseRouteRouteHeadersMap: S.Schema<EditRouteResponseRouteRouteHeadersMap>;
+export type EditRouteResponseRouteRouteMethodsList = Array<string>;
+export declare const EditRouteResponseRouteRouteMethodsList: S.Schema<EditRouteResponseRouteRouteMethodsList>;
+export type EditRouteResponseRouteRouteHasItemCase0Type = "host";
+export declare const EditRouteResponseRouteRouteHasItemCase0Type: any;
+export type EditRouteResponseRouteRouteHasItemCase0ValueCase1Eq = string | number;
+export declare const EditRouteResponseRouteRouteHasItemCase0ValueCase1Eq: S.Schema<EditRouteResponseRouteRouteHasItemCase0ValueCase1Eq>;
+export type EditRouteResponseRouteRouteHasItemCase0ValueCase1IncList = Array<string>;
+export declare const EditRouteResponseRouteRouteHasItemCase0ValueCase1IncList: S.Schema<EditRouteResponseRouteRouteHasItemCase0ValueCase1IncList>;
+export type EditRouteResponseRouteRouteHasItemCase0ValueCase1NincList = Array<string>;
+export declare const EditRouteResponseRouteRouteHasItemCase0ValueCase1NincList: S.Schema<EditRouteResponseRouteRouteHasItemCase0ValueCase1NincList>;
+export interface EditRouteResponseRouteRouteHasItemCase0ValueCase1 {
+    eq?: EditRouteResponseRouteRouteHasItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: EditRouteResponseRouteRouteHasItemCase0ValueCase1IncList;
+    ninc?: EditRouteResponseRouteRouteHasItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const EditRouteResponseRouteRouteHasItemCase0ValueCase1: S.Schema<EditRouteResponseRouteRouteHasItemCase0ValueCase1>;
+export type EditRouteResponseRouteRouteHasItemCase0Value = string | EditRouteResponseRouteRouteHasItemCase0ValueCase1;
+export declare const EditRouteResponseRouteRouteHasItemCase0Value: S.Schema<EditRouteResponseRouteRouteHasItemCase0Value>;
+export interface EditRouteResponseRouteRouteHasItemCase0 {
+    type: EditRouteResponseRouteRouteHasItemCase0Type;
+    value: EditRouteResponseRouteRouteHasItemCase0Value;
+}
+export declare const EditRouteResponseRouteRouteHasItemCase0: S.Schema<EditRouteResponseRouteRouteHasItemCase0>;
+export type EditRouteResponseRouteRouteHasItemCase1Type = "cookie" | "header" | "query";
+export declare const EditRouteResponseRouteRouteHasItemCase1Type: any;
+export type EditRouteResponseRouteRouteHasItemCase1ValueCase1Eq = string | number;
+export declare const EditRouteResponseRouteRouteHasItemCase1ValueCase1Eq: S.Schema<EditRouteResponseRouteRouteHasItemCase1ValueCase1Eq>;
+export type EditRouteResponseRouteRouteHasItemCase1ValueCase1IncList = Array<string>;
+export declare const EditRouteResponseRouteRouteHasItemCase1ValueCase1IncList: S.Schema<EditRouteResponseRouteRouteHasItemCase1ValueCase1IncList>;
+export type EditRouteResponseRouteRouteHasItemCase1ValueCase1NincList = Array<string>;
+export declare const EditRouteResponseRouteRouteHasItemCase1ValueCase1NincList: S.Schema<EditRouteResponseRouteRouteHasItemCase1ValueCase1NincList>;
+export interface EditRouteResponseRouteRouteHasItemCase1ValueCase1 {
+    eq?: EditRouteResponseRouteRouteHasItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: EditRouteResponseRouteRouteHasItemCase1ValueCase1IncList;
+    ninc?: EditRouteResponseRouteRouteHasItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const EditRouteResponseRouteRouteHasItemCase1ValueCase1: S.Schema<EditRouteResponseRouteRouteHasItemCase1ValueCase1>;
+export type EditRouteResponseRouteRouteHasItemCase1Value = string | EditRouteResponseRouteRouteHasItemCase1ValueCase1;
+export declare const EditRouteResponseRouteRouteHasItemCase1Value: S.Schema<EditRouteResponseRouteRouteHasItemCase1Value>;
+export interface EditRouteResponseRouteRouteHasItemCase1 {
+    type: EditRouteResponseRouteRouteHasItemCase1Type;
+    key: string;
+    value?: EditRouteResponseRouteRouteHasItemCase1Value;
+}
+export declare const EditRouteResponseRouteRouteHasItemCase1: S.Schema<EditRouteResponseRouteRouteHasItemCase1>;
+export type EditRouteResponseRouteRouteHasItem = EditRouteResponseRouteRouteHasItemCase0 | EditRouteResponseRouteRouteHasItemCase1;
+export declare const EditRouteResponseRouteRouteHasItem: S.Schema<EditRouteResponseRouteRouteHasItem>;
+export type EditRouteResponseRouteRouteHasList = Array<EditRouteResponseRouteRouteHasItem>;
+export declare const EditRouteResponseRouteRouteHasList: S.Schema<EditRouteResponseRouteRouteHasList>;
+export type EditRouteResponseRouteRouteMissingItemCase0Type = "host";
+export declare const EditRouteResponseRouteRouteMissingItemCase0Type: any;
+export type EditRouteResponseRouteRouteMissingItemCase0ValueCase1Eq = string | number;
+export declare const EditRouteResponseRouteRouteMissingItemCase0ValueCase1Eq: S.Schema<EditRouteResponseRouteRouteMissingItemCase0ValueCase1Eq>;
+export type EditRouteResponseRouteRouteMissingItemCase0ValueCase1IncList = Array<string>;
+export declare const EditRouteResponseRouteRouteMissingItemCase0ValueCase1IncList: S.Schema<EditRouteResponseRouteRouteMissingItemCase0ValueCase1IncList>;
+export type EditRouteResponseRouteRouteMissingItemCase0ValueCase1NincList = Array<string>;
+export declare const EditRouteResponseRouteRouteMissingItemCase0ValueCase1NincList: S.Schema<EditRouteResponseRouteRouteMissingItemCase0ValueCase1NincList>;
+export interface EditRouteResponseRouteRouteMissingItemCase0ValueCase1 {
+    eq?: EditRouteResponseRouteRouteMissingItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: EditRouteResponseRouteRouteMissingItemCase0ValueCase1IncList;
+    ninc?: EditRouteResponseRouteRouteMissingItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const EditRouteResponseRouteRouteMissingItemCase0ValueCase1: S.Schema<EditRouteResponseRouteRouteMissingItemCase0ValueCase1>;
+export type EditRouteResponseRouteRouteMissingItemCase0Value = string | EditRouteResponseRouteRouteMissingItemCase0ValueCase1;
+export declare const EditRouteResponseRouteRouteMissingItemCase0Value: S.Schema<EditRouteResponseRouteRouteMissingItemCase0Value>;
+export interface EditRouteResponseRouteRouteMissingItemCase0 {
+    type: EditRouteResponseRouteRouteMissingItemCase0Type;
+    value: EditRouteResponseRouteRouteMissingItemCase0Value;
+}
+export declare const EditRouteResponseRouteRouteMissingItemCase0: S.Schema<EditRouteResponseRouteRouteMissingItemCase0>;
+export type EditRouteResponseRouteRouteMissingItemCase1Type = "cookie" | "header" | "query";
+export declare const EditRouteResponseRouteRouteMissingItemCase1Type: any;
+export type EditRouteResponseRouteRouteMissingItemCase1ValueCase1Eq = string | number;
+export declare const EditRouteResponseRouteRouteMissingItemCase1ValueCase1Eq: S.Schema<EditRouteResponseRouteRouteMissingItemCase1ValueCase1Eq>;
+export type EditRouteResponseRouteRouteMissingItemCase1ValueCase1IncList = Array<string>;
+export declare const EditRouteResponseRouteRouteMissingItemCase1ValueCase1IncList: S.Schema<EditRouteResponseRouteRouteMissingItemCase1ValueCase1IncList>;
+export type EditRouteResponseRouteRouteMissingItemCase1ValueCase1NincList = Array<string>;
+export declare const EditRouteResponseRouteRouteMissingItemCase1ValueCase1NincList: S.Schema<EditRouteResponseRouteRouteMissingItemCase1ValueCase1NincList>;
+export interface EditRouteResponseRouteRouteMissingItemCase1ValueCase1 {
+    eq?: EditRouteResponseRouteRouteMissingItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: EditRouteResponseRouteRouteMissingItemCase1ValueCase1IncList;
+    ninc?: EditRouteResponseRouteRouteMissingItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const EditRouteResponseRouteRouteMissingItemCase1ValueCase1: S.Schema<EditRouteResponseRouteRouteMissingItemCase1ValueCase1>;
+export type EditRouteResponseRouteRouteMissingItemCase1Value = string | EditRouteResponseRouteRouteMissingItemCase1ValueCase1;
+export declare const EditRouteResponseRouteRouteMissingItemCase1Value: S.Schema<EditRouteResponseRouteRouteMissingItemCase1Value>;
+export interface EditRouteResponseRouteRouteMissingItemCase1 {
+    type: EditRouteResponseRouteRouteMissingItemCase1Type;
+    key: string;
+    value?: EditRouteResponseRouteRouteMissingItemCase1Value;
+}
+export declare const EditRouteResponseRouteRouteMissingItemCase1: S.Schema<EditRouteResponseRouteRouteMissingItemCase1>;
+export type EditRouteResponseRouteRouteMissingItem = EditRouteResponseRouteRouteMissingItemCase0 | EditRouteResponseRouteRouteMissingItemCase1;
+export declare const EditRouteResponseRouteRouteMissingItem: S.Schema<EditRouteResponseRouteRouteMissingItem>;
+export type EditRouteResponseRouteRouteMissingList = Array<EditRouteResponseRouteRouteMissingItem>;
+export declare const EditRouteResponseRouteRouteMissingList: S.Schema<EditRouteResponseRouteRouteMissingList>;
+export type EditRouteResponseRouteRouteMitigateAction = "challenge" | "deny";
+export declare const EditRouteResponseRouteRouteMitigateAction: any;
+export interface EditRouteResponseRouteRouteMitigate {
+    action: EditRouteResponseRouteRouteMitigateAction;
+}
+export declare const EditRouteResponseRouteRouteMitigate: S.Schema<EditRouteResponseRouteRouteMitigate>;
+export type EditRouteResponseRouteRouteTransformsItemCase0Type = "request.headers" | "request.query" | "response.headers";
+export declare const EditRouteResponseRouteRouteTransformsItemCase0Type: any;
+export type EditRouteResponseRouteRouteTransformsItemCase0Op = "append" | "delete" | "set";
+export declare const EditRouteResponseRouteRouteTransformsItemCase0Op: any;
+export type EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq = string | number;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq>;
+export type EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList = Array<string>;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList>;
+export type EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList = Array<string>;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList>;
+export interface EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1 {
+    eq?: EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1Eq;
+    neq?: string;
+    inc?: EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1IncList;
+    ninc?: EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1NincList;
+    pre?: string;
+    suf?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1>;
+export type EditRouteResponseRouteRouteTransformsItemCase0TargetKey = string | EditRouteResponseRouteRouteTransformsItemCase0TargetKeyCase1;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0TargetKey: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0TargetKey>;
+export interface EditRouteResponseRouteRouteTransformsItemCase0Target {
+    key: EditRouteResponseRouteRouteTransformsItemCase0TargetKey;
+}
+export declare const EditRouteResponseRouteRouteTransformsItemCase0Target: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0Target>;
+export type EditRouteResponseRouteRouteTransformsItemCase0ArgsCase1List = Array<string>;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0ArgsCase1List: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0ArgsCase1List>;
+export type EditRouteResponseRouteRouteTransformsItemCase0Args = string | EditRouteResponseRouteRouteTransformsItemCase0ArgsCase1List;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0Args: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0Args>;
+export type EditRouteResponseRouteRouteTransformsItemCase0EnvList = Array<string>;
+export declare const EditRouteResponseRouteRouteTransformsItemCase0EnvList: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0EnvList>;
+export interface EditRouteResponseRouteRouteTransformsItemCase0 {
+    type: EditRouteResponseRouteRouteTransformsItemCase0Type;
+    op: EditRouteResponseRouteRouteTransformsItemCase0Op;
+    target: EditRouteResponseRouteRouteTransformsItemCase0Target;
+    args?: EditRouteResponseRouteRouteTransformsItemCase0Args;
+    env?: EditRouteResponseRouteRouteTransformsItemCase0EnvList;
+}
+export declare const EditRouteResponseRouteRouteTransformsItemCase0: S.Schema<EditRouteResponseRouteRouteTransformsItemCase0>;
+export type EditRouteResponseRouteRouteTransformsItemCase1Type = "request.path";
+export declare const EditRouteResponseRouteRouteTransformsItemCase1Type: any;
+export type EditRouteResponseRouteRouteTransformsItemCase1Op = "set";
+export declare const EditRouteResponseRouteRouteTransformsItemCase1Op: any;
+export type EditRouteResponseRouteRouteTransformsItemCase1EnvList = Array<string>;
+export declare const EditRouteResponseRouteRouteTransformsItemCase1EnvList: S.Schema<EditRouteResponseRouteRouteTransformsItemCase1EnvList>;
+export interface EditRouteResponseRouteRouteTransformsItemCase1 {
+    type: EditRouteResponseRouteRouteTransformsItemCase1Type;
+    op: EditRouteResponseRouteRouteTransformsItemCase1Op;
+    args: string;
+    env?: EditRouteResponseRouteRouteTransformsItemCase1EnvList;
+}
+export declare const EditRouteResponseRouteRouteTransformsItemCase1: S.Schema<EditRouteResponseRouteRouteTransformsItemCase1>;
+export type EditRouteResponseRouteRouteTransformsItem = EditRouteResponseRouteRouteTransformsItemCase0 | EditRouteResponseRouteRouteTransformsItemCase1;
+export declare const EditRouteResponseRouteRouteTransformsItem: S.Schema<EditRouteResponseRouteRouteTransformsItem>;
+export type EditRouteResponseRouteRouteTransformsList = Array<EditRouteResponseRouteRouteTransformsItem>;
+export declare const EditRouteResponseRouteRouteTransformsList: S.Schema<EditRouteResponseRouteRouteTransformsList>;
+export type EditRouteResponseRouteRouteEnvList = Array<string>;
+export declare const EditRouteResponseRouteRouteEnvList: S.Schema<EditRouteResponseRouteRouteEnvList>;
+export type EditRouteResponseRouteRouteLocaleRedirectMap = {
+    [key: string]: string | undefined;
+};
+export declare const EditRouteResponseRouteRouteLocaleRedirectMap: S.Schema<EditRouteResponseRouteRouteLocaleRedirectMap>;
+export interface EditRouteResponseRouteRouteLocale {
+    redirect?: EditRouteResponseRouteRouteLocaleRedirectMap;
+    cookie?: string;
+}
+export declare const EditRouteResponseRouteRouteLocale: S.Schema<EditRouteResponseRouteRouteLocale>;
+/** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+export type EditRouteResponseRouteRouteDestinationCase1Type = "service";
+export declare const EditRouteResponseRouteRouteDestinationCase1Type: any;
+export interface EditRouteResponseRouteRouteDestinationCase1 {
+    /** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+    type?: EditRouteResponseRouteRouteDestinationCase1Type;
+    service: string;
+    /** Routing-only path used to select a route inside the target service. */
+    path?: string;
+}
+export declare const EditRouteResponseRouteRouteDestinationCase1: S.Schema<EditRouteResponseRouteRouteDestinationCase1>;
+export type EditRouteResponseRouteRouteDestination = string | EditRouteResponseRouteRouteDestinationCase1;
+export declare const EditRouteResponseRouteRouteDestination: S.Schema<EditRouteResponseRouteRouteDestination>;
+/** The original middleware matchers. */
+export type EditRouteResponseRouteRouteMiddlewareRawSrcList = Array<string>;
+export declare const EditRouteResponseRouteRouteMiddlewareRawSrcList: S.Schema<EditRouteResponseRouteRouteMiddlewareRawSrcList>;
+/** The route definition from @vercel/routing-utils. */
+export interface EditRouteResponseRouteRoute {
+    src: string;
+    dest?: string;
+    headers?: EditRouteResponseRouteRouteHeadersMap;
+    methods?: EditRouteResponseRouteRouteMethodsList;
+    continue?: boolean;
+    override?: boolean;
+    caseSensitive?: boolean;
+    check?: boolean;
+    important?: boolean;
+    status?: number;
+    has?: EditRouteResponseRouteRouteHasList;
+    missing?: EditRouteResponseRouteRouteMissingList;
+    mitigate?: EditRouteResponseRouteRouteMitigate;
+    transforms?: EditRouteResponseRouteRouteTransformsList;
+    env?: EditRouteResponseRouteRouteEnvList;
+    locale?: EditRouteResponseRouteRouteLocale;
+    /** Aliases for `src`, `dest`, and `status`. These provide consistency with the `rewrites`, `redirects`, and `headers` fields which use `source`, `destination`, and `statusCode`. During normalization, the string forms are converted to their canonical forms (`src`, `dest`, `status`) and stripped from the route object. `destination` may also be a service-targeted object, in which case routing is delegated into the named service's internal route table and the object is preserved as-is (not folded into `dest`). */
+    source?: string;
+    destination?: EditRouteResponseRouteRouteDestination;
+    statusCode?: number;
+    /** A middleware key within the `output` key under the build result. Overrides a `middleware` definition. */
+    middlewarePath?: string;
+    /** The original middleware matchers. */
+    middlewareRawSrc?: EditRouteResponseRouteRouteMiddlewareRawSrcList;
+    /** A middleware index in the `middleware` key under the build result */
+    middleware?: number;
+    respectOriginCacheControl?: boolean;
+}
+export declare const EditRouteResponseRouteRoute: S.Schema<EditRouteResponseRouteRoute>;
+/** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+export type EditRouteResponseRouteSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const EditRouteResponseRouteSrcSyntax: any;
+export interface EditRouteResponseRoute {
+    routeType?: EditRouteResponseRouteRouteType;
+    /** Unique identifier for the routing rule. */
+    id: string;
+    /** Human-readable name for the routing rule. */
+    name: string;
+    /** Optional description of what the routing rule does. */
+    description?: string;
+    /** Whether the routing rule is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Whether this route is new and not yet published to production. Set to true only when a route is first created via add-route. Cleared (set to false) when a version is promoted to production. */
+    staged?: boolean;
+    /** The route definition from @vercel/routing-utils. */
+    route: EditRouteResponseRouteRoute;
+    /** Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses. */
+    rawSrc?: string;
+    /** Original destination provided by user. */
+    rawDest?: string;
+    /** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+    srcSyntax?: EditRouteResponseRouteSrcSyntax;
+}
+export declare const EditRouteResponseRoute: S.Schema<EditRouteResponseRoute>;
+/** A version of routing rules stored in S3. */
+export type EditRouteResponseVersion = AddRouteResponseVersion;
+export declare const EditRouteResponseVersion: S.Schema<AddRouteResponseVersion>;
+export interface EditRouteResponse {
+    route?: EditRouteResponseRoute;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const EditRouteResponse: S.Schema<EditRouteResponse>;
+export interface GenerateRouteRequestCurrentRoutePathCondition {
+    value?: string;
+    syntax?: string;
+}
+export declare const GenerateRouteRequestCurrentRoutePathCondition: S.Schema<GenerateRouteRequestCurrentRoutePathCondition>;
+export interface GenerateRouteRequestCurrentRouteConditionsItem {
+    field?: string;
+    operator?: string;
+    key?: string;
+    value?: string;
+    missing?: boolean;
+}
+export declare const GenerateRouteRequestCurrentRouteConditionsItem: S.Schema<GenerateRouteRequestCurrentRouteConditionsItem>;
+export type GenerateRouteRequestCurrentRouteConditionsList = Array<GenerateRouteRequestCurrentRouteConditionsItem>;
+export declare const GenerateRouteRequestCurrentRouteConditionsList: S.Schema<GenerateRouteRequestCurrentRouteConditionsList>;
+export interface GenerateRouteRequestCurrentRouteActionsItemHeadersItem {
+    key?: string;
+    value?: string;
+    op?: string;
+}
+export declare const GenerateRouteRequestCurrentRouteActionsItemHeadersItem: S.Schema<GenerateRouteRequestCurrentRouteActionsItemHeadersItem>;
+export type GenerateRouteRequestCurrentRouteActionsItemHeadersList = Array<GenerateRouteRequestCurrentRouteActionsItemHeadersItem>;
+export declare const GenerateRouteRequestCurrentRouteActionsItemHeadersList: S.Schema<GenerateRouteRequestCurrentRouteActionsItemHeadersList>;
+export interface GenerateRouteRequestCurrentRouteActionsItem {
+    type?: string;
+    subType?: string;
+    dest?: string;
+    status?: number;
+    headers?: GenerateRouteRequestCurrentRouteActionsItemHeadersList;
+}
+export declare const GenerateRouteRequestCurrentRouteActionsItem: S.Schema<GenerateRouteRequestCurrentRouteActionsItem>;
+export type GenerateRouteRequestCurrentRouteActionsList = Array<GenerateRouteRequestCurrentRouteActionsItem>;
+export declare const GenerateRouteRequestCurrentRouteActionsList: S.Schema<GenerateRouteRequestCurrentRouteActionsList>;
+export interface GenerateRouteRequestCurrentRoute {
+    name?: string;
+    description?: string;
+    pathCondition: GenerateRouteRequestCurrentRoutePathCondition;
+    conditions?: GenerateRouteRequestCurrentRouteConditionsList;
+    actions: GenerateRouteRequestCurrentRouteActionsList;
+}
+export declare const GenerateRouteRequestCurrentRoute: S.Schema<GenerateRouteRequestCurrentRoute>;
+export interface GenerateRouteRequest {
+    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;
+    prompt: string;
+    currentRoute?: GenerateRouteRequestCurrentRoute;
+}
+export declare const GenerateRouteRequest: S.Schema<GenerateRouteRequest>;
+export type GenerateRouteResponseRoutePathConditionSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const GenerateRouteResponseRoutePathConditionSyntax: any;
+export interface GenerateRouteResponseRoutePathCondition {
+    value: string;
+    syntax: GenerateRouteResponseRoutePathConditionSyntax;
+}
+export declare const GenerateRouteResponseRoutePathCondition: S.Schema<GenerateRouteResponseRoutePathCondition>;
+export type GenerateRouteResponseRouteConditionsItemField = "cookie" | "header" | "host" | "query";
+export declare const GenerateRouteResponseRouteConditionsItemField: any;
+export type GenerateRouteResponseRouteConditionsItemOperator = "contains" | "eq" | "exists" | "re";
+export declare const GenerateRouteResponseRouteConditionsItemOperator: any;
+export interface GenerateRouteResponseRouteConditionsItem {
+    field: GenerateRouteResponseRouteConditionsItemField;
+    operator: GenerateRouteResponseRouteConditionsItemOperator;
+    key?: string;
+    value?: string;
+    missing: boolean;
+}
+export declare const GenerateRouteResponseRouteConditionsItem: S.Schema<GenerateRouteResponseRouteConditionsItem>;
+export type GenerateRouteResponseRouteConditionsList = Array<GenerateRouteResponseRouteConditionsItem>;
+export declare const GenerateRouteResponseRouteConditionsList: S.Schema<GenerateRouteResponseRouteConditionsList>;
+export type GenerateRouteResponseRouteActionsItemType = "modify" | "redirect" | "rewrite" | "set-status";
+export declare const GenerateRouteResponseRouteActionsItemType: any;
+export type GenerateRouteResponseRouteActionsItemSubType = "response-headers" | "transform-request-header" | "transform-request-query";
+export declare const GenerateRouteResponseRouteActionsItemSubType: any;
+export type GenerateRouteResponseRouteActionsItemHeadersItemOp = "append" | "delete" | "set";
+export declare const GenerateRouteResponseRouteActionsItemHeadersItemOp: any;
+export interface GenerateRouteResponseRouteActionsItemHeadersItem {
+    key: string;
+    value?: string;
+    op: GenerateRouteResponseRouteActionsItemHeadersItemOp;
+}
+export declare const GenerateRouteResponseRouteActionsItemHeadersItem: S.Schema<GenerateRouteResponseRouteActionsItemHeadersItem>;
+export type GenerateRouteResponseRouteActionsItemHeadersList = Array<GenerateRouteResponseRouteActionsItemHeadersItem>;
+export declare const GenerateRouteResponseRouteActionsItemHeadersList: S.Schema<GenerateRouteResponseRouteActionsItemHeadersList>;
+export interface GenerateRouteResponseRouteActionsItem {
+    type: GenerateRouteResponseRouteActionsItemType;
+    subType?: GenerateRouteResponseRouteActionsItemSubType;
+    dest?: string;
+    status?: number;
+    headers?: GenerateRouteResponseRouteActionsItemHeadersList;
+}
+export declare const GenerateRouteResponseRouteActionsItem: S.Schema<GenerateRouteResponseRouteActionsItem>;
+export type GenerateRouteResponseRouteActionsList = Array<GenerateRouteResponseRouteActionsItem>;
+export declare const GenerateRouteResponseRouteActionsList: S.Schema<GenerateRouteResponseRouteActionsList>;
+export interface GenerateRouteResponseRoute {
+    name: string;
+    description: string;
+    pathCondition: GenerateRouteResponseRoutePathCondition;
+    conditions?: GenerateRouteResponseRouteConditionsList;
+    actions: GenerateRouteResponseRouteActionsList;
+}
+export declare const GenerateRouteResponseRoute: S.Schema<GenerateRouteResponseRoute>;
+export interface GenerateRouteResponse {
+    route?: GenerateRouteResponseRoute;
+    error?: string;
+}
+export declare const GenerateRouteResponse: S.Schema<GenerateRouteResponse>;
+export type GetRoutesRequestFilter = "rewrite" | "redirect" | "set_status" | "transform";
+export declare const GetRoutesRequestFilter: any;
+export type GetRoutesRequestDiffCase1 = "only";
+export declare const GetRoutesRequestDiffCase1: any;
+export type GetRoutesRequestDiff = boolean | GetRoutesRequestDiffCase1;
+export declare const GetRoutesRequestDiff: S.Schema<GetRoutesRequestDiff>;
+export interface GetRoutesRequest {
+    projectId: string;
+    versionId?: string;
+    q?: string;
+    filter?: GetRoutesRequestFilter | (string & {});
+    diff?: GetRoutesRequestDiff;
+    /** 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 GetRoutesRequest: S.Schema<GetRoutesRequest>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHeadersMap: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHeadersMap>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMethodsList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMethodsList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMethodsList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Value = string | GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Value: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Value>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Type;
+    value: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Value = string | GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Value: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Value>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasItem = GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase0 | GetRoutesResponseBodyCase1RoutesItemRouteHasItemCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasItem: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasItem>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteHasList = Array<GetRoutesResponseBodyCase1RoutesItemRouteHasItem>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteHasList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteHasList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Value = string | GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Value: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Value>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Type;
+    value: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Value = string | GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Value: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Value>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingItem = GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase0 | GetRoutesResponseBodyCase1RoutesItemRouteMissingItemCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingItem: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingItem>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMissingList = Array<GetRoutesResponseBodyCase1RoutesItemRouteMissingItem>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMissingList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMissingList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteMitigateAction = "challenge" | "deny";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMitigateAction: any;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteMitigate {
+    action: GetRoutesResponseBodyCase1RoutesItemRouteMitigateAction;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMitigate: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMitigate>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Type = "request.headers" | "request.query" | "response.headers";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Op = "append" | "delete" | "set";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Op: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1 {
+    eq?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList;
+    ninc?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList;
+    pre?: string;
+    suf?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKey = string | GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKeyCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKey: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKey>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Target {
+    key: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0TargetKey;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Target: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Target>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0ArgsCase1List = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0ArgsCase1List: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0ArgsCase1List>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Args = string | GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0ArgsCase1List;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Args: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Args>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0EnvList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0EnvList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Type;
+    op: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Op;
+    target: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Target;
+    args?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0Args;
+    env?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0EnvList;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Type = "request.path";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Type: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Op = "set";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Op: any;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1EnvList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1EnvList>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1 {
+    type: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Type;
+    op: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1Op;
+    args: string;
+    env?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1EnvList;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsItem = GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase0 | GetRoutesResponseBodyCase1RoutesItemRouteTransformsItemCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsItem: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItem>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteTransformsList = Array<GetRoutesResponseBodyCase1RoutesItemRouteTransformsItem>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteTransformsList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteTransformsList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteEnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteEnvList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteEnvList>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteLocaleRedirectMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteLocaleRedirectMap: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteLocaleRedirectMap>;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteLocale {
+    redirect?: GetRoutesResponseBodyCase1RoutesItemRouteLocaleRedirectMap;
+    cookie?: string;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteLocale: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteLocale>;
+/** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+export type GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1Type = "service";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1Type: any;
+export interface GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1 {
+    /** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+    type?: GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1Type;
+    service: string;
+    /** Routing-only path used to select a route inside the target service. */
+    path?: string;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1>;
+export type GetRoutesResponseBodyCase1RoutesItemRouteDestination = string | GetRoutesResponseBodyCase1RoutesItemRouteDestinationCase1;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteDestination: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteDestination>;
+/** The original middleware matchers. */
+export type GetRoutesResponseBodyCase1RoutesItemRouteMiddlewareRawSrcList = Array<string>;
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteMiddlewareRawSrcList: S.Schema<GetRoutesResponseBodyCase1RoutesItemRouteMiddlewareRawSrcList>;
+/** The route definition from @vercel/routing-utils. */
+export interface GetRoutesResponseBodyCase1RoutesItemRoute {
+    src: string;
+    dest?: string;
+    headers?: GetRoutesResponseBodyCase1RoutesItemRouteHeadersMap;
+    methods?: GetRoutesResponseBodyCase1RoutesItemRouteMethodsList;
+    continue?: boolean;
+    override?: boolean;
+    caseSensitive?: boolean;
+    check?: boolean;
+    important?: boolean;
+    status?: number;
+    has?: GetRoutesResponseBodyCase1RoutesItemRouteHasList;
+    missing?: GetRoutesResponseBodyCase1RoutesItemRouteMissingList;
+    mitigate?: GetRoutesResponseBodyCase1RoutesItemRouteMitigate;
+    transforms?: GetRoutesResponseBodyCase1RoutesItemRouteTransformsList;
+    env?: GetRoutesResponseBodyCase1RoutesItemRouteEnvList;
+    locale?: GetRoutesResponseBodyCase1RoutesItemRouteLocale;
+    /** Aliases for `src`, `dest`, and `status`. These provide consistency with the `rewrites`, `redirects`, and `headers` fields which use `source`, `destination`, and `statusCode`. During normalization, the string forms are converted to their canonical forms (`src`, `dest`, `status`) and stripped from the route object. `destination` may also be a service-targeted object, in which case routing is delegated into the named service's internal route table and the object is preserved as-is (not folded into `dest`). */
+    source?: string;
+    destination?: GetRoutesResponseBodyCase1RoutesItemRouteDestination;
+    statusCode?: number;
+    /** A middleware key within the `output` key under the build result. Overrides a `middleware` definition. */
+    middlewarePath?: string;
+    /** The original middleware matchers. */
+    middlewareRawSrc?: GetRoutesResponseBodyCase1RoutesItemRouteMiddlewareRawSrcList;
+    /** A middleware index in the `middleware` key under the build result */
+    middleware?: number;
+    respectOriginCacheControl?: boolean;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItemRoute: S.Schema<GetRoutesResponseBodyCase1RoutesItemRoute>;
+/** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+export type GetRoutesResponseBodyCase1RoutesItemSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const GetRoutesResponseBodyCase1RoutesItemSrcSyntax: any;
+/** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+export type GetRoutesResponseBodyCase1RoutesItemRouteType = "redirect" | "rewrite" | "set_status" | "transform";
+export declare const GetRoutesResponseBodyCase1RoutesItemRouteType: any;
+/** A routing rule with metadata for project-level routing. */
+export interface GetRoutesResponseBodyCase1RoutesItem {
+    /** Unique identifier for the routing rule. */
+    id: string;
+    /** Human-readable name for the routing rule. */
+    name: string;
+    /** Optional description of what the routing rule does. */
+    description?: string;
+    /** Whether the routing rule is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Whether this route is new and not yet published to production. Set to true only when a route is first created via add-route. Cleared (set to false) when a version is promoted to production. */
+    staged?: boolean;
+    /** The route definition from @vercel/routing-utils. */
+    route: GetRoutesResponseBodyCase1RoutesItemRoute;
+    /** Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses. */
+    rawSrc?: string;
+    /** Original destination provided by user. */
+    rawDest?: string;
+    /** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+    srcSyntax?: GetRoutesResponseBodyCase1RoutesItemSrcSyntax;
+    /** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+    routeType?: GetRoutesResponseBodyCase1RoutesItemRouteType;
+}
+export declare const GetRoutesResponseBodyCase1RoutesItem: S.Schema<GetRoutesResponseBodyCase1RoutesItem>;
+export type GetRoutesResponseBodyCase1RoutesList = Array<GetRoutesResponseBodyCase1RoutesItem>;
+export declare const GetRoutesResponseBodyCase1RoutesList: S.Schema<GetRoutesResponseBodyCase1RoutesList>;
+/** A version of routing rules stored in S3. */
+export type GetRoutesResponseBodyCase1Version = AddRouteResponseVersion;
+export declare const GetRoutesResponseBodyCase1Version: S.Schema<AddRouteResponseVersion>;
+export interface GetRoutesResponseBodyCase1 {
+    routes: GetRoutesResponseBodyCase1RoutesList;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+    diffCount: number;
+}
+export declare const GetRoutesResponseBodyCase1: S.Schema<GetRoutesResponseBodyCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHeadersMap: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHeadersMap>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMethodsList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMethodsList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMethodsList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Value = string | GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Value: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Value>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Type;
+    value: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Value = string | GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Value: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Value>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasItem = GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase0 | GetRoutesResponseBodyCase2RoutesItemRouteHasItemCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasItem: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasItem>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteHasList = Array<GetRoutesResponseBodyCase2RoutesItemRouteHasItem>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteHasList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteHasList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Value = string | GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Value: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Value>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Type;
+    value: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Value = string | GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Value: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Value>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingItem = GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase0 | GetRoutesResponseBodyCase2RoutesItemRouteMissingItemCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingItem: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingItem>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMissingList = Array<GetRoutesResponseBodyCase2RoutesItemRouteMissingItem>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMissingList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMissingList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteMitigateAction = "challenge" | "deny";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMitigateAction: any;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteMitigate {
+    action: GetRoutesResponseBodyCase2RoutesItemRouteMitigateAction;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMitigate: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMitigate>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Type = "request.headers" | "request.query" | "response.headers";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Op = "append" | "delete" | "set";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Op: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1 {
+    eq?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList;
+    ninc?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList;
+    pre?: string;
+    suf?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKey = string | GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKeyCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKey: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKey>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Target {
+    key: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0TargetKey;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Target: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Target>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0ArgsCase1List = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0ArgsCase1List: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0ArgsCase1List>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Args = string | GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0ArgsCase1List;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Args: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Args>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0EnvList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0EnvList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Type;
+    op: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Op;
+    target: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Target;
+    args?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0Args;
+    env?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0EnvList;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Type = "request.path";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Type: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Op = "set";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Op: any;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1EnvList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1EnvList>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1 {
+    type: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Type;
+    op: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1Op;
+    args: string;
+    env?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1EnvList;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsItem = GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase0 | GetRoutesResponseBodyCase2RoutesItemRouteTransformsItemCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsItem: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItem>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteTransformsList = Array<GetRoutesResponseBodyCase2RoutesItemRouteTransformsItem>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteTransformsList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteTransformsList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteEnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteEnvList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteEnvList>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteLocaleRedirectMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteLocaleRedirectMap: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteLocaleRedirectMap>;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteLocale {
+    redirect?: GetRoutesResponseBodyCase2RoutesItemRouteLocaleRedirectMap;
+    cookie?: string;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteLocale: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteLocale>;
+/** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+export type GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1Type = "service";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1Type: any;
+export interface GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1 {
+    /** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+    type?: GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1Type;
+    service: string;
+    /** Routing-only path used to select a route inside the target service. */
+    path?: string;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1>;
+export type GetRoutesResponseBodyCase2RoutesItemRouteDestination = string | GetRoutesResponseBodyCase2RoutesItemRouteDestinationCase1;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteDestination: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteDestination>;
+/** The original middleware matchers. */
+export type GetRoutesResponseBodyCase2RoutesItemRouteMiddlewareRawSrcList = Array<string>;
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteMiddlewareRawSrcList: S.Schema<GetRoutesResponseBodyCase2RoutesItemRouteMiddlewareRawSrcList>;
+/** The route definition from @vercel/routing-utils. */
+export interface GetRoutesResponseBodyCase2RoutesItemRoute {
+    src: string;
+    dest?: string;
+    headers?: GetRoutesResponseBodyCase2RoutesItemRouteHeadersMap;
+    methods?: GetRoutesResponseBodyCase2RoutesItemRouteMethodsList;
+    continue?: boolean;
+    override?: boolean;
+    caseSensitive?: boolean;
+    check?: boolean;
+    important?: boolean;
+    status?: number;
+    has?: GetRoutesResponseBodyCase2RoutesItemRouteHasList;
+    missing?: GetRoutesResponseBodyCase2RoutesItemRouteMissingList;
+    mitigate?: GetRoutesResponseBodyCase2RoutesItemRouteMitigate;
+    transforms?: GetRoutesResponseBodyCase2RoutesItemRouteTransformsList;
+    env?: GetRoutesResponseBodyCase2RoutesItemRouteEnvList;
+    locale?: GetRoutesResponseBodyCase2RoutesItemRouteLocale;
+    /** Aliases for `src`, `dest`, and `status`. These provide consistency with the `rewrites`, `redirects`, and `headers` fields which use `source`, `destination`, and `statusCode`. During normalization, the string forms are converted to their canonical forms (`src`, `dest`, `status`) and stripped from the route object. `destination` may also be a service-targeted object, in which case routing is delegated into the named service's internal route table and the object is preserved as-is (not folded into `dest`). */
+    source?: string;
+    destination?: GetRoutesResponseBodyCase2RoutesItemRouteDestination;
+    statusCode?: number;
+    /** A middleware key within the `output` key under the build result. Overrides a `middleware` definition. */
+    middlewarePath?: string;
+    /** The original middleware matchers. */
+    middlewareRawSrc?: GetRoutesResponseBodyCase2RoutesItemRouteMiddlewareRawSrcList;
+    /** A middleware index in the `middleware` key under the build result */
+    middleware?: number;
+    respectOriginCacheControl?: boolean;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItemRoute: S.Schema<GetRoutesResponseBodyCase2RoutesItemRoute>;
+/** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+export type GetRoutesResponseBodyCase2RoutesItemSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const GetRoutesResponseBodyCase2RoutesItemSrcSyntax: any;
+/** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+export type GetRoutesResponseBodyCase2RoutesItemRouteType = "redirect" | "rewrite" | "set_status" | "transform";
+export declare const GetRoutesResponseBodyCase2RoutesItemRouteType: any;
+/** A routing rule with metadata for project-level routing. */
+export interface GetRoutesResponseBodyCase2RoutesItem {
+    /** Unique identifier for the routing rule. */
+    id: string;
+    /** Human-readable name for the routing rule. */
+    name: string;
+    /** Optional description of what the routing rule does. */
+    description?: string;
+    /** Whether the routing rule is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Whether this route is new and not yet published to production. Set to true only when a route is first created via add-route. Cleared (set to false) when a version is promoted to production. */
+    staged?: boolean;
+    /** The route definition from @vercel/routing-utils. */
+    route: GetRoutesResponseBodyCase2RoutesItemRoute;
+    /** Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses. */
+    rawSrc?: string;
+    /** Original destination provided by user. */
+    rawDest?: string;
+    /** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+    srcSyntax?: GetRoutesResponseBodyCase2RoutesItemSrcSyntax;
+    /** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+    routeType?: GetRoutesResponseBodyCase2RoutesItemRouteType;
+}
+export declare const GetRoutesResponseBodyCase2RoutesItem: S.Schema<GetRoutesResponseBodyCase2RoutesItem>;
+export type GetRoutesResponseBodyCase2RoutesList = Array<GetRoutesResponseBodyCase2RoutesItem>;
+export declare const GetRoutesResponseBodyCase2RoutesList: S.Schema<GetRoutesResponseBodyCase2RoutesList>;
+/** A version of routing rules stored in S3. */
+export type GetRoutesResponseBodyCase2Version = AddRouteResponseVersion;
+export declare const GetRoutesResponseBodyCase2Version: S.Schema<AddRouteResponseVersion>;
+export interface GetRoutesResponseBodyCase2 {
+    routes: GetRoutesResponseBodyCase2RoutesList;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const GetRoutesResponseBodyCase2: S.Schema<GetRoutesResponseBodyCase2>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHeadersMap: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHeadersMap>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMethodsList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMethodsList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMethodsList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Value = string | GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Value: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Value>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Type;
+    value: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Value = string | GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Value: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Value>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasItem = GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase0 | GetRoutesResponseBodyCase3RoutesItemRouteHasItemCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasItem: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasItem>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteHasList = Array<GetRoutesResponseBodyCase3RoutesItemRouteHasItem>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteHasList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteHasList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Type = "host";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1Eq>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1IncList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1 {
+    eq?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Value = string | GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0ValueCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Value: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Value>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Type;
+    value: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0Value;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Type = "cookie" | "header" | "query";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1Eq: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1Eq>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1IncList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1IncList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1NincList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1NincList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1 {
+    eq?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1IncList;
+    ninc?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1NincList;
+    pre?: string;
+    suf?: string;
+    re?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Value = string | GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1ValueCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Value: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Value>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Type;
+    key: string;
+    value?: GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1Value;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingItem = GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase0 | GetRoutesResponseBodyCase3RoutesItemRouteMissingItemCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingItem: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingItem>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMissingList = Array<GetRoutesResponseBodyCase3RoutesItemRouteMissingItem>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMissingList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMissingList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteMitigateAction = "challenge" | "deny";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMitigateAction: any;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteMitigate {
+    action: GetRoutesResponseBodyCase3RoutesItemRouteMitigateAction;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMitigate: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMitigate>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Type = "request.headers" | "request.query" | "response.headers";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Op = "append" | "delete" | "set";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Op: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq = string | number;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1 {
+    eq?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1Eq;
+    neq?: string;
+    inc?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1IncList;
+    ninc?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1NincList;
+    pre?: string;
+    suf?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKey = string | GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKeyCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKey: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKey>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Target {
+    key: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0TargetKey;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Target: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Target>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0ArgsCase1List = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0ArgsCase1List: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0ArgsCase1List>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Args = string | GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0ArgsCase1List;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Args: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Args>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0EnvList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0EnvList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Type;
+    op: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Op;
+    target: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Target;
+    args?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0Args;
+    env?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0EnvList;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Type = "request.path";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Type: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Op = "set";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Op: any;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1EnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1EnvList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1EnvList>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1 {
+    type: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Type;
+    op: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1Op;
+    args: string;
+    env?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1EnvList;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsItem = GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase0 | GetRoutesResponseBodyCase3RoutesItemRouteTransformsItemCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsItem: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItem>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteTransformsList = Array<GetRoutesResponseBodyCase3RoutesItemRouteTransformsItem>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteTransformsList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteTransformsList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteEnvList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteEnvList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteEnvList>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteLocaleRedirectMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteLocaleRedirectMap: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteLocaleRedirectMap>;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteLocale {
+    redirect?: GetRoutesResponseBodyCase3RoutesItemRouteLocaleRedirectMap;
+    cookie?: string;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteLocale: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteLocale>;
+/** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+export type GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1Type = "service";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1Type: any;
+export interface GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1 {
+    /** Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required. */
+    type?: GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1Type;
+    service: string;
+    /** Routing-only path used to select a route inside the target service. */
+    path?: string;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1>;
+export type GetRoutesResponseBodyCase3RoutesItemRouteDestination = string | GetRoutesResponseBodyCase3RoutesItemRouteDestinationCase1;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteDestination: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteDestination>;
+/** The original middleware matchers. */
+export type GetRoutesResponseBodyCase3RoutesItemRouteMiddlewareRawSrcList = Array<string>;
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteMiddlewareRawSrcList: S.Schema<GetRoutesResponseBodyCase3RoutesItemRouteMiddlewareRawSrcList>;
+/** The route definition from @vercel/routing-utils. */
+export interface GetRoutesResponseBodyCase3RoutesItemRoute {
+    src: string;
+    dest?: string;
+    headers?: GetRoutesResponseBodyCase3RoutesItemRouteHeadersMap;
+    methods?: GetRoutesResponseBodyCase3RoutesItemRouteMethodsList;
+    continue?: boolean;
+    override?: boolean;
+    caseSensitive?: boolean;
+    check?: boolean;
+    important?: boolean;
+    status?: number;
+    has?: GetRoutesResponseBodyCase3RoutesItemRouteHasList;
+    missing?: GetRoutesResponseBodyCase3RoutesItemRouteMissingList;
+    mitigate?: GetRoutesResponseBodyCase3RoutesItemRouteMitigate;
+    transforms?: GetRoutesResponseBodyCase3RoutesItemRouteTransformsList;
+    env?: GetRoutesResponseBodyCase3RoutesItemRouteEnvList;
+    locale?: GetRoutesResponseBodyCase3RoutesItemRouteLocale;
+    /** Aliases for `src`, `dest`, and `status`. These provide consistency with the `rewrites`, `redirects`, and `headers` fields which use `source`, `destination`, and `statusCode`. During normalization, the string forms are converted to their canonical forms (`src`, `dest`, `status`) and stripped from the route object. `destination` may also be a service-targeted object, in which case routing is delegated into the named service's internal route table and the object is preserved as-is (not folded into `dest`). */
+    source?: string;
+    destination?: GetRoutesResponseBodyCase3RoutesItemRouteDestination;
+    statusCode?: number;
+    /** A middleware key within the `output` key under the build result. Overrides a `middleware` definition. */
+    middlewarePath?: string;
+    /** The original middleware matchers. */
+    middlewareRawSrc?: GetRoutesResponseBodyCase3RoutesItemRouteMiddlewareRawSrcList;
+    /** A middleware index in the `middleware` key under the build result */
+    middleware?: number;
+    respectOriginCacheControl?: boolean;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItemRoute: S.Schema<GetRoutesResponseBodyCase3RoutesItemRoute>;
+/** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+export type GetRoutesResponseBodyCase3RoutesItemSrcSyntax = "equals" | "path-to-regexp" | "regex";
+export declare const GetRoutesResponseBodyCase3RoutesItemSrcSyntax: any;
+/** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+export type GetRoutesResponseBodyCase3RoutesItemRouteType = "redirect" | "rewrite" | "set_status" | "transform";
+export declare const GetRoutesResponseBodyCase3RoutesItemRouteType: any;
+/** A routing rule with metadata for project-level routing. */
+export interface GetRoutesResponseBodyCase3RoutesItem {
+    /** Unique identifier for the routing rule. */
+    id: string;
+    /** Human-readable name for the routing rule. */
+    name: string;
+    /** Optional description of what the routing rule does. */
+    description?: string;
+    /** Whether the routing rule is enabled. Defaults to true. */
+    enabled?: boolean;
+    /** Whether this route is new and not yet published to production. Set to true only when a route is first created via add-route. Cleared (set to false) when a version is promoted to production. */
+    staged?: boolean;
+    /** The route definition from @vercel/routing-utils. */
+    route: GetRoutesResponseBodyCase3RoutesItemRoute;
+    /** Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses. */
+    rawSrc?: string;
+    /** Original destination provided by user. */
+    rawDest?: string;
+    /** The syntax type of the source pattern. Determines how the pattern is compiled to regex. */
+    srcSyntax?: GetRoutesResponseBodyCase3RoutesItemSrcSyntax;
+    /** Computed route type based on the route configuration. Only present in API responses, not stored in S3. */
+    routeType?: GetRoutesResponseBodyCase3RoutesItemRouteType;
+}
+export declare const GetRoutesResponseBodyCase3RoutesItem: S.Schema<GetRoutesResponseBodyCase3RoutesItem>;
+export type GetRoutesResponseBodyCase3RoutesList = Array<GetRoutesResponseBodyCase3RoutesItem>;
+export declare const GetRoutesResponseBodyCase3RoutesList: S.Schema<GetRoutesResponseBodyCase3RoutesList>;
+/** A version of routing rules stored in S3. */
+export type GetRoutesResponseBodyCase3Version = AddRouteResponseVersion;
+export declare const GetRoutesResponseBodyCase3Version: S.Schema<AddRouteResponseVersion>;
+export interface GetRoutesResponseBodyCase3Limit {
+    maxRoutes: number;
+    currentRoutes: number;
+}
+export declare const GetRoutesResponseBodyCase3Limit: S.Schema<GetRoutesResponseBodyCase3Limit>;
+export interface GetRoutesResponseBodyCase3 {
+    routes: GetRoutesResponseBodyCase3RoutesList;
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+    limit: GetRoutesResponseBodyCase3Limit;
+}
+export declare const GetRoutesResponseBodyCase3: S.Schema<GetRoutesResponseBodyCase3>;
+export type GetRoutesResponseBody = unknown | GetRoutesResponseBodyCase1 | GetRoutesResponseBodyCase2 | GetRoutesResponseBodyCase3;
+export declare const GetRoutesResponseBody: S.Schema<GetRoutesResponseBody>;
+export type GetRoutesResponse = GetRoutesResponseBody;
+export declare const GetRoutesResponse: S.Schema<GetRoutesResponse>;
+export interface GetRouteVersionsRequest {
+    projectId: string;
+    /** The Team identifier to perform the request on behalf of. */
+    teamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetRouteVersionsRequest: S.Schema<GetRouteVersionsRequest>;
+/** A version of routing rules stored in S3. */
+export type GetRouteVersionsResponseVersionsItem = AddRouteResponseVersion;
+export declare const GetRouteVersionsResponseVersionsItem: S.Schema<AddRouteResponseVersion>;
+export type GetRouteVersionsResponseVersionsList = Array<AddRouteResponseVersion>;
+export declare const GetRouteVersionsResponseVersionsList: S.Schema<GetRouteVersionsResponseVersionsList>;
+export interface GetRouteVersionsResponse {
+    versions: GetRouteVersionsResponseVersionsList;
+}
+export declare const GetRouteVersionsResponse: S.Schema<GetRouteVersionsResponse>;
+export type StageRoutesRequestRoutesItemRouteHasItemType = "host" | "header" | "cookie" | "query";
+export declare const StageRoutesRequestRoutesItemRouteHasItemType: any;
+export interface StageRoutesRequestRoutesItemRouteHasItem {
+    type?: StageRoutesRequestRoutesItemRouteHasItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const StageRoutesRequestRoutesItemRouteHasItem: S.Schema<StageRoutesRequestRoutesItemRouteHasItem>;
+export type StageRoutesRequestRoutesItemRouteHasList = Array<StageRoutesRequestRoutesItemRouteHasItem>;
+export declare const StageRoutesRequestRoutesItemRouteHasList: S.Schema<StageRoutesRequestRoutesItemRouteHasList>;
+export type StageRoutesRequestRoutesItemRouteMissingItemType = "host" | "header" | "cookie" | "query";
+export declare const StageRoutesRequestRoutesItemRouteMissingItemType: any;
+export interface StageRoutesRequestRoutesItemRouteMissingItem {
+    type?: StageRoutesRequestRoutesItemRouteMissingItemType | (string & {});
+    key?: string;
+    value?: string;
+}
+export declare const StageRoutesRequestRoutesItemRouteMissingItem: S.Schema<StageRoutesRequestRoutesItemRouteMissingItem>;
+export type StageRoutesRequestRoutesItemRouteMissingList = Array<StageRoutesRequestRoutesItemRouteMissingItem>;
+export declare const StageRoutesRequestRoutesItemRouteMissingList: S.Schema<StageRoutesRequestRoutesItemRouteMissingList>;
+export type StageRoutesRequestRoutesItemRouteTransformsItemType = "request.headers" | "request.query" | "response.headers";
+export declare const StageRoutesRequestRoutesItemRouteTransformsItemType: any;
+export type StageRoutesRequestRoutesItemRouteTransformsItemOp = "append" | "set" | "delete";
+export declare const StageRoutesRequestRoutesItemRouteTransformsItemOp: any;
+export type StageRoutesRequestRoutesItemRouteTransformsItemEnvList = Array<string>;
+export declare const StageRoutesRequestRoutesItemRouteTransformsItemEnvList: S.Schema<StageRoutesRequestRoutesItemRouteTransformsItemEnvList>;
+export interface StageRoutesRequestRoutesItemRouteTransformsItem {
+    type?: StageRoutesRequestRoutesItemRouteTransformsItemType | (string & {});
+    op?: StageRoutesRequestRoutesItemRouteTransformsItemOp | (string & {});
+    target?: unknown;
+    args?: unknown;
+    env?: StageRoutesRequestRoutesItemRouteTransformsItemEnvList;
+}
+export declare const StageRoutesRequestRoutesItemRouteTransformsItem: S.Schema<StageRoutesRequestRoutesItemRouteTransformsItem>;
+export type StageRoutesRequestRoutesItemRouteTransformsList = Array<StageRoutesRequestRoutesItemRouteTransformsItem>;
+export declare const StageRoutesRequestRoutesItemRouteTransformsList: S.Schema<StageRoutesRequestRoutesItemRouteTransformsList>;
+export interface StageRoutesRequestRoutesItemRoute {
+    src: string;
+    dest?: string;
+    headers?: unknown;
+    caseSensitive?: boolean;
+    status?: number;
+    has?: StageRoutesRequestRoutesItemRouteHasList;
+    missing?: StageRoutesRequestRoutesItemRouteMissingList;
+    transforms?: StageRoutesRequestRoutesItemRouteTransformsList;
+    respectOriginCacheControl?: boolean;
+}
+export declare const StageRoutesRequestRoutesItemRoute: S.Schema<StageRoutesRequestRoutesItemRoute>;
+export interface StageRoutesRequestRoutesItem {
+    id: string;
+    name: string;
+    description?: string;
+    enabled?: boolean;
+    route: StageRoutesRequestRoutesItemRoute;
+}
+export declare const StageRoutesRequestRoutesItem: S.Schema<StageRoutesRequestRoutesItem>;
+export type StageRoutesRequestRoutesList = Array<StageRoutesRequestRoutesItem>;
+export declare const StageRoutesRequestRoutesList: S.Schema<StageRoutesRequestRoutesList>;
+export interface StageRoutesRequest {
+    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;
+    overwrite?: boolean;
+    routes?: StageRoutesRequestRoutesList;
+}
+export declare const StageRoutesRequest: S.Schema<StageRoutesRequest>;
+/** A version of routing rules stored in S3. */
+export type StageRoutesResponseVersion = AddRouteResponseVersion;
+export declare const StageRoutesResponseVersion: S.Schema<AddRouteResponseVersion>;
+export interface StageRoutesResponse {
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const StageRoutesResponse: S.Schema<StageRoutesResponse>;
+export type UpdateRouteVersionsRequestAction = "promote" | "restore" | "discard";
+export declare const UpdateRouteVersionsRequestAction: any;
+export interface UpdateRouteVersionsRequest {
+    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;
+    id: string;
+    action: UpdateRouteVersionsRequestAction | (string & {});
+}
+export declare const UpdateRouteVersionsRequest: S.Schema<UpdateRouteVersionsRequest>;
+/** A version of routing rules stored in S3. */
+export type UpdateRouteVersionsResponseVersion = AddRouteResponseVersion;
+export declare const UpdateRouteVersionsResponseVersion: S.Schema<AddRouteResponseVersion>;
+export interface UpdateRouteVersionsResponse {
+    /** A version of routing rules stored in S3. */
+    version: AddRouteResponseVersion;
+}
+export declare const UpdateRouteVersionsResponse: S.Schema<UpdateRouteVersionsResponse>;
+export type AddRouteError = BadRequest | Forbidden | Conflict | VercelOpError;
+/** Add a routing rule Add a single routing rule to a project at a specified position. Defaults to the end of the list if no position is provided. The route is enabled by default. Stages a new version with the added route. */
+export declare const addRoute: API.OperationMethod<AddRouteRequest, AddRouteResponse, AddRouteError, VercelOpContext>;
+export type DeleteRoutesError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
+/** Delete routing rules Delete one or more routing rules from a project by ID. Stages a new version with the routes removed. */
+export declare const deleteRoutes: API.OperationMethod<DeleteRoutesRequest, DeleteRoutesResponse, DeleteRoutesError, VercelOpContext>;
+export type EditRouteError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
+/** Edit a routing rule Replace a routing rule identified by its ID, or restore it from the current production version. Stages a new version with the modified route. */
+export declare const editRoute: API.OperationMethod<EditRouteRequest, EditRouteResponse, EditRouteError, VercelOpContext>;
+export type GenerateRouteError = BadRequest | Forbidden | VercelOpError;
+/** Generate a routing rule from natural language Generate a routing rule configuration from a natural language description. Returns a suggested route configuration that can be reviewed and saved. */
+export declare const generateRoute: API.OperationMethod<GenerateRouteRequest, GenerateRouteResponse, GenerateRouteError, VercelOpContext>;
+export type GetRoutesError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get project routing rules Get the routing rules for a project. Supports searching by name/ID/pattern, filtering by route type, and diffing staged changes against production. */
+export declare const getRoutes: API.OperationMethod<GetRoutesRequest, GetRoutesResponse, GetRoutesError, VercelOpContext>;
+export type GetRouteVersionsError = BadRequest | Forbidden | VercelOpError;
+/** Get routing rule version history Get the version history for a project's routing rules. Returns the staging version (if one exists) followed by production versions, most recent first. The staging version has `isStaging: true` and the current production version has `isLive: true`. */
+export declare const getRouteVersions: API.OperationMethod<GetRouteVersionsRequest, GetRouteVersionsResponse, GetRouteVersionsError, VercelOpContext>;
+export type StageRoutesError = BadRequest | Forbidden | Conflict | VercelOpError;
+/** Stage routing rules Stage routing rules for a project. Set `overwrite` to true to replace all existing rules, or omit it to merge with existing rules by ID. Returns the new staged version. */
+export declare const stageRoutes: API.OperationMethod<StageRoutesRequest, StageRoutesResponse, StageRoutesError, VercelOpContext>;
+export type UpdateRouteVersionsError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
+/** Promote, restore, or discard a routing rule version Promote staged routing rules to production, restore a previous production version, or discard staged changes. - `promote`: Publishes the staging version to production. - `restore`: Rolls back to a previous production version. - `discard`: Removes the staging version without publishing. */
+export declare const updateRouteVersions: API.OperationMethod<UpdateRouteVersionsRequest, UpdateRouteVersionsResponse, UpdateRouteVersionsError, VercelOpContext>;
+//# sourceMappingURL=project_routes.d.ts.map