@vercel/sdk/src/models/addrouteop.ts

<p align="center"> <a href="https://vercel.com"> <img src="https://assets.vercel.com/image/upload/v1588805858/repositories/vercel/logo.png" height="96"> <h3 align="center">Vercel</h3> </a> <p align="center">Develop. Preview. Ship.</p> </p>

/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { remap as remap$ } from "../lib/primitives.js";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

/**
 * Pattern syntax type. If not provided, inferred from pattern.
 */
export const SrcSyntax = {
  Equals: "equals",
  PathToRegexp: "path-to-regexp",
  Regex: "regex",
} as const;
/**
 * Pattern syntax type. If not provided, inferred from pattern.
 */
export type SrcSyntax = ClosedEnum<typeof SrcSyntax>;

export type AddRouteHeaders = {};

export const AddRouteType = {
  Host: "host",
  Header: "header",
  Cookie: "cookie",
  Query: "query",
} as const;
export type AddRouteType = ClosedEnum<typeof AddRouteType>;

export type AddRouteHas = {
  type?: AddRouteType | undefined;
  key?: string | undefined;
  value?: string | undefined;
};

export const AddRouteProjectRoutesType = {
  Host: "host",
  Header: "header",
  Cookie: "cookie",
  Query: "query",
} as const;
export type AddRouteProjectRoutesType = ClosedEnum<
  typeof AddRouteProjectRoutesType
>;

export type AddRouteMissing = {
  type?: AddRouteProjectRoutesType | undefined;
  key?: string | undefined;
  value?: string | undefined;
};

export const AddRouteProjectRoutesRequestType = {
  RequestHeaders: "request.headers",
  RequestQuery: "request.query",
  ResponseHeaders: "response.headers",
} as const;
export type AddRouteProjectRoutesRequestType = ClosedEnum<
  typeof AddRouteProjectRoutesRequestType
>;

export const AddRouteOp = {
  Append: "append",
  Set: "set",
  Delete: "delete",
} as const;
export type AddRouteOp = ClosedEnum<typeof AddRouteOp>;

export type AddRouteTarget = {};

export type AddRouteTransforms = {
  type?: AddRouteProjectRoutesRequestType | undefined;
  op?: AddRouteOp | undefined;
  target?: AddRouteTarget | undefined;
  args?: any | undefined;
  env?: Array<string> | undefined;
};

export type AddRouteProjectRoutesRoute = {
  src: string;
  dest?: string | undefined;
  headers?: AddRouteHeaders | undefined;
  caseSensitive?: boolean | undefined;
  status?: number | undefined;
  has?: Array<AddRouteHas> | undefined;
  missing?: Array<AddRouteMissing> | undefined;
  transforms?: Array<AddRouteTransforms> | undefined;
  respectOriginCacheControl?: boolean | undefined;
};

export type AddRouteRoute = {
  name: string;
  description?: string | undefined;
  enabled?: boolean | undefined;
  /**
   * Pattern syntax type. If not provided, inferred from pattern.
   */
  srcSyntax?: SrcSyntax | undefined;
  route: AddRouteProjectRoutesRoute;
};

/**
 * "after"/"before" require referenceId.
 */
export const Placement = {
  Start: "start",
  End: "end",
  After: "after",
  Before: "before",
} as const;
/**
 * "after"/"before" require referenceId.
 */
export type Placement = ClosedEnum<typeof Placement>;

/**
 * Controls where the route is inserted. Defaults to "end" if omitted.
 */
export type Position = {
  /**
   * "after"/"before" require referenceId.
   */
  placement?: Placement | undefined;
  /**
   * Route ID to insert after/before. Required for "after"/"before".
   */
  referenceId?: string | undefined;
};

export type AddRouteRequestBody = {
  route: AddRouteRoute;
  /**
   * Controls where the route is inserted. Defaults to "end" if omitted.
   */
  position?: Position | undefined;
};

export type AddRouteRequest = {
  projectId: string;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
  requestBody?: AddRouteRequestBody | undefined;
};

export const RouteType = {
  Redirect: "redirect",
  Rewrite: "rewrite",
  SetStatus: "set_status",
  Transform: "transform",
} as const;
export type RouteType = ClosedEnum<typeof RouteType>;

export const AddRouteHasProjectRoutesType = {
  Cookie: "cookie",
  Header: "header",
  Query: "query",
} as const;
export type AddRouteHasProjectRoutesType = ClosedEnum<
  typeof AddRouteHasProjectRoutesType
>;

export type AddRouteValueProjectRoutesEq = string | number;

export type AddRouteValueProjectRoutes2 = {
  eq?: string | number | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  re?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type AddRouteHasProjectRoutesValue =
  | string
  | AddRouteValueProjectRoutes2;

export type AddRouteHas2 = {
  type: AddRouteHasProjectRoutesType;
  key: string;
  value?: string | AddRouteValueProjectRoutes2 | undefined;
};

export type AddRouteValueEq = string | number;

export type AddRouteValue2 = {
  eq?: string | number | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  re?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type AddRouteHasValue = string | AddRouteValue2;

export type AddRouteHas1 = {
  type: "host";
  value: string | AddRouteValue2;
};

export type AddRouteProjectRoutesHas =
  | AddRouteHas1
  | (AddRouteHas2 & { type: "cookie" })
  | (AddRouteHas2 & { type: "header" })
  | (AddRouteHas2 & { type: "query" });

export const AddRouteMissingProjectRoutesType = {
  Cookie: "cookie",
  Header: "header",
  Query: "query",
} as const;
export type AddRouteMissingProjectRoutesType = ClosedEnum<
  typeof AddRouteMissingProjectRoutesType
>;

export type AddRouteValueProjectRoutesResponse200Eq = string | number;

export type AddRouteValueProjectRoutesResponse2002 = {
  eq?: string | number | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  re?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type AddRouteMissingProjectRoutesValue =
  | string
  | AddRouteValueProjectRoutesResponse2002;

export type AddRouteMissing2 = {
  type: AddRouteMissingProjectRoutesType;
  key: string;
  value?: string | AddRouteValueProjectRoutesResponse2002 | undefined;
};

export type AddRouteValueProjectRoutesResponseEq = string | number;

export type AddRouteValueProjectRoutesResponse2 = {
  eq?: string | number | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  re?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type AddRouteMissingValue = string | AddRouteValueProjectRoutesResponse2;

export type AddRouteMissing1 = {
  type: "host";
  value: string | AddRouteValueProjectRoutesResponse2;
};

export type AddRouteProjectRoutesMissing =
  | AddRouteMissing1
  | (AddRouteMissing2 & { type: "cookie" })
  | (AddRouteMissing2 & { type: "header" })
  | (AddRouteMissing2 & { type: "query" });

export const AddRouteAction = {
  Challenge: "challenge",
  Deny: "deny",
} as const;
export type AddRouteAction = ClosedEnum<typeof AddRouteAction>;

export type AddRouteMitigate = {
  action: AddRouteAction;
};

export const AddRouteTransformsProjectRoutesOp = {
  Set: "set",
} as const;
export type AddRouteTransformsProjectRoutesOp = ClosedEnum<
  typeof AddRouteTransformsProjectRoutesOp
>;

export type AddRouteTransforms2 = {
  type: "request.path";
  op: AddRouteTransformsProjectRoutesOp;
  args: string;
  env?: Array<string> | undefined;
};

export const AddRouteTransformsType = {
  RequestHeaders: "request.headers",
  RequestQuery: "request.query",
  ResponseHeaders: "response.headers",
} as const;
export type AddRouteTransformsType = ClosedEnum<typeof AddRouteTransformsType>;

export const AddRouteTransformsOp = {
  Append: "append",
  Delete: "delete",
  Set: "set",
} as const;
export type AddRouteTransformsOp = ClosedEnum<typeof AddRouteTransformsOp>;

export type AddRouteKeyEq = string | number;

export type AddRouteKey2 = {
  eq?: string | number | undefined;
  neq?: string | undefined;
  inc?: Array<string> | undefined;
  ninc?: Array<string> | undefined;
  pre?: string | undefined;
  suf?: string | undefined;
  gt?: number | undefined;
  gte?: number | undefined;
  lt?: number | undefined;
  lte?: number | undefined;
};

export type TransformsKey = string | AddRouteKey2;

export type AddRouteTransformsTarget = {
  key: string | AddRouteKey2;
};

export type TransformsArgs = string | Array<string>;

export type AddRouteTransforms1 = {
  type: AddRouteTransformsType;
  op: AddRouteTransformsOp;
  target: AddRouteTransformsTarget;
  args?: string | Array<string> | undefined;
  env?: Array<string> | undefined;
};

export type AddRouteProjectRoutesTransforms =
  | (AddRouteTransforms1 & { type: "request.headers" })
  | (AddRouteTransforms1 & { type: "request.query" })
  | (AddRouteTransforms1 & { type: "response.headers" })
  | AddRouteTransforms2;

export type AddRouteLocale = {
  redirect?: { [k: string]: string } | undefined;
  cookie?: string | undefined;
};

/**
 * Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required.
 */
export const AddRouteDestinationType = {
  Service: "service",
} as const;
/**
 * Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required.
 */
export type AddRouteDestinationType = ClosedEnum<
  typeof AddRouteDestinationType
>;

export type AddRouteDestination2 = {
  /**
   * Optional explicit format marker. The destination is identified by the presence of `service`, so `type` is no longer required.
   */
  type?: AddRouteDestinationType | undefined;
  service: string;
  /**
   * Routing-only path used to select a route inside the target service.
   */
  path?: string | undefined;
};

export type AddRouteDestination = AddRouteDestination2 | string;

/**
 * The route definition from @vercel/routing-utils.
 */
export type AddRouteProjectRoutesResponse200Route = {
  src: string;
  dest?: string | undefined;
  headers?: { [k: string]: string } | undefined;
  methods?: Array<string> | undefined;
  continue?: boolean | undefined;
  override?: boolean | undefined;
  caseSensitive?: boolean | undefined;
  check?: boolean | undefined;
  important?: boolean | undefined;
  status?: number | undefined;
  has?:
    | Array<
      | AddRouteHas1
      | (AddRouteHas2 & { type: "cookie" })
      | (AddRouteHas2 & { type: "header" })
      | (AddRouteHas2 & { type: "query" })
    >
    | undefined;
  missing?:
    | Array<
      | AddRouteMissing1
      | (AddRouteMissing2 & { type: "cookie" })
      | (AddRouteMissing2 & { type: "header" })
      | (AddRouteMissing2 & { type: "query" })
    >
    | undefined;
  mitigate?: AddRouteMitigate | undefined;
  transforms?:
    | Array<
      | (AddRouteTransforms1 & { type: "request.headers" })
      | (AddRouteTransforms1 & { type: "request.query" })
      | (AddRouteTransforms1 & { type: "response.headers" })
      | AddRouteTransforms2
    >
    | undefined;
  env?: Array<string> | undefined;
  locale?: AddRouteLocale | undefined;
  /**
   * 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 | undefined;
  destination?: AddRouteDestination2 | string | undefined;
  statusCode?: number | undefined;
  /**
   * A middleware key within the `output` key under the build result. Overrides a `middleware` definition.
   */
  middlewarePath?: string | undefined;
  /**
   * The original middleware matchers.
   */
  middlewareRawSrc?: Array<string> | undefined;
  /**
   * A middleware index in the `middleware` key under the build result
   */
  middleware?: number | undefined;
  respectOriginCacheControl?: boolean | undefined;
};

/**
 * The syntax type of the source pattern. Determines how the pattern is compiled to regex.
 */
export const AddRouteSrcSyntax = {
  Equals: "equals",
  PathToRegexp: "path-to-regexp",
  Regex: "regex",
} as const;
/**
 * The syntax type of the source pattern. Determines how the pattern is compiled to regex.
 */
export type AddRouteSrcSyntax = ClosedEnum<typeof AddRouteSrcSyntax>;

export type AddRouteProjectRoutesResponseRoute = {
  routeType?: RouteType | undefined;
  /**
   * 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 | undefined;
  /**
   * Whether the routing rule is enabled. Defaults to true.
   */
  enabled?: boolean | undefined;
  /**
   * 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 | undefined;
  /**
   * The route definition from @vercel/routing-utils.
   */
  route: AddRouteProjectRoutesResponse200Route;
  /**
   * Original source pattern provided by user (path-to-regexp or regex). Used to display the user's input in API responses.
   */
  rawSrc?: string | undefined;
  /**
   * Original destination provided by user.
   */
  rawDest?: string | undefined;
  /**
   * The syntax type of the source pattern. Determines how the pattern is compiled to regex.
   */
  srcSyntax?: AddRouteSrcSyntax | undefined;
};

/**
 * A version of routing rules stored in S3.
 */
export type AddRouteVersion = {
  /**
   * 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 | undefined;
  /**
   * Whether this version is currently live in production.
   */
  isLive?: boolean | undefined;
  /**
   * The number of routing rules in this version.
   */
  ruleCount?: number | undefined;
  /**
   * The staging alias for previewing this version.
   */
  alias?: string | undefined;
};

export type AddRouteResponseBody = {
  route: AddRouteProjectRoutesResponseRoute;
  /**
   * A version of routing rules stored in S3.
   */
  version: AddRouteVersion;
};

/** @internal */
export const SrcSyntax$outboundSchema: z.ZodNativeEnum<typeof SrcSyntax> = z
  .nativeEnum(SrcSyntax);

/** @internal */
export type AddRouteHeaders$Outbound = {};

/** @internal */
export const AddRouteHeaders$outboundSchema: z.ZodType<
  AddRouteHeaders$Outbound,
  z.ZodTypeDef,
  AddRouteHeaders
> = z.object({});

export function addRouteHeadersToJSON(
  addRouteHeaders: AddRouteHeaders,
): string {
  return JSON.stringify(AddRouteHeaders$outboundSchema.parse(addRouteHeaders));
}

/** @internal */
export const AddRouteType$outboundSchema: z.ZodNativeEnum<typeof AddRouteType> =
  z.nativeEnum(AddRouteType);

/** @internal */
export type AddRouteHas$Outbound = {
  type?: string | undefined;
  key?: string | undefined;
  value?: string | undefined;
};

/** @internal */
export const AddRouteHas$outboundSchema: z.ZodType<
  AddRouteHas$Outbound,
  z.ZodTypeDef,
  AddRouteHas
> = z.object({
  type: AddRouteType$outboundSchema.optional(),
  key: z.string().optional(),
  value: z.string().optional(),
});

export function addRouteHasToJSON(addRouteHas: AddRouteHas): string {
  return JSON.stringify(AddRouteHas$outboundSchema.parse(addRouteHas));
}

/** @internal */
export const AddRouteProjectRoutesType$outboundSchema: z.ZodNativeEnum<
  typeof AddRouteProjectRoutesType
> = z.nativeEnum(AddRouteProjectRoutesType);

/** @internal */
export type AddRouteMissing$Outbound = {
  type?: string | undefined;
  key?: string | undefined;
  value?: string | undefined;
};

/** @internal */
export const AddRouteMissing$outboundSchema: z.ZodType<
  AddRouteMissing$Outbound,
  z.ZodTypeDef,
  AddRouteMissing
> = z.object({
  type: AddRouteProjectRoutesType$outboundSchema.optional(),
  key: z.string().optional(),
  value: z.string().optional(),
});

export function addRouteMissingToJSON(
  addRouteMissing: AddRouteMissing,
): string {
  return JSON.stringify(AddRouteMissing$outboundSchema.parse(addRouteMissing));
}

/** @internal */
export const AddRouteProjectRoutesRequestType$outboundSchema: z.ZodNativeEnum<
  typeof AddRouteProjectRoutesRequestType
> = z.nativeEnum(AddRouteProjectRoutesRequestType);

/** @internal */
export const AddRouteOp$outboundSchema: z.ZodNativeEnum<typeof AddRouteOp> = z
  .nativeEnum(AddRouteOp);

/** @internal */
export type AddRouteTarget$Outbound = {};

/** @internal */
export const AddRouteTarget$outboundSchema: z.ZodType<
  AddRouteTarget$Outbound,
  z.ZodTypeDef,
  AddRouteTarget
> = z.object({});

export function addRouteTargetToJSON(addRouteTarget: AddRouteTarget): string {
  return JSON.stringify(AddRouteTarget$outboundSchema.parse(addRouteTarget));
}

/** @internal */
export type AddRouteTransforms$Outbound = {
  type?: string | undefined;
  op?: string | undefined;
  target?: AddRouteTarget$Outbound | undefined;
  args?: any | undefined;
  env?: Array<string> | undefined;
};

/** @internal */
export const AddRouteTransforms$outboundSchema: z.ZodType<
  AddRouteTransforms$Outbound,
  z.ZodTypeDef,
  AddRouteTransforms
> = z.object({
  type: AddRouteProjectRoutesRequestType$outboundSchema.optional(),
  op: AddRouteOp$outboundSchema.optional(),
  target: z.lazy(() => AddRouteTarget$outboundSchema).optional(),
  args: z.any().optional(),
  env: z.array(z.string()).optional(),
});

export function addRouteTransformsToJSON(
  addRouteTransforms: AddRouteTransforms,
): string {
  return JSON.stringify(
    AddRouteTransforms$outboundSchema.parse(addRouteTransforms),
  );
}

/** @internal */
export type AddRouteProjectRoutesRoute$Outbound = {
  src: string;
  dest?: string | undefined;
  headers?: AddRouteHeaders$Outbound | undefined;
  caseSensitive?: boolean | undefined;
  status?: number | undefined;
  has?: Array<AddRouteHas$Outbound> | undefined;
  missing?: Array<AddRouteMissing$Outbound> | undefined;
  transforms?: Array<AddRouteTransforms$Outbound> | undefined;
  respectOriginCacheControl?: boolean | undefined;
};

/** @internal */
export const AddRouteProjectRoutesRoute$outboundSchema: z.ZodType<
  AddRouteProjectRoutesRoute$Outbound,
  z.ZodTypeDef,
  AddRouteProjectRoutesRoute
> = z.object({
  src: z.string(),
  dest: z.string().optional(),
  headers: z.lazy(() => AddRouteHeaders$outboundSchema).optional(),
  caseSensitive: z.boolean().optional(),
  status: z.number().int().optional(),
  has: z.array(z.lazy(() => AddRouteHas$outboundSchema)).optional(),
  missing: z.array(z.lazy(() => AddRouteMissing$outboundSchema)).optional(),
  transforms: z.array(z.lazy(() => AddRouteTransforms$outboundSchema))
    .optional(),
  respectOriginCacheControl: z.boolean().optional(),
});

export function addRouteProjectRoutesRouteToJSON(
  addRouteProjectRoutesRoute: AddRouteProjectRoutesRoute,
): string {
  return JSON.stringify(
    AddRouteProjectRoutesRoute$outboundSchema.parse(addRouteProjectRoutesRoute),
  );
}

/** @internal */
export type AddRouteRoute$Outbound = {
  name: string;
  description?: string | undefined;
  enabled?: boolean | undefined;
  srcSyntax?: string | undefined;
  route: AddRouteProjectRoutesRoute$Outbound;
};

/** @internal */
export const AddRouteRoute$outboundSchema: z.ZodType<
  AddRouteRoute$Outbound,
  z.ZodTypeDef,
  AddRouteRoute
> = z.object({
  name: z.string(),
  description: z.string().optional(),
  enabled: z.boolean().optional(),
  srcSyntax: SrcSyntax$outboundSchema.optional(),
  route: z.lazy(() => AddRouteProjectRoutesRoute$outboundSchema),
});

export function addRouteRouteToJSON(addRouteRoute: AddRouteRoute): string {
  return JSON.stringify(AddRouteRoute$outboundSchema.parse(addRouteRoute));
}

/** @internal */
export const Placement$outboundSchema: z.ZodNativeEnum<typeof Placement> = z
  .nativeEnum(Placement);

/** @internal */
export type Position$Outbound = {
  placement?: string | undefined;
  referenceId?: string | undefined;
};

/** @internal */
export const Position$outboundSchema: z.ZodType<
  Position$Outbound,
  z.ZodTypeDef,
  Position
> = z.object({
  placement: Placement$outboundSchema.optional(),
  referenceId: z.string().optional(),
});

export function positionToJSON(position: Position): string {
  return JSON.stringify(Position$outboundSchema.parse(position));
}

/** @internal */
export type AddRouteRequestBody$Outbound = {
  route: AddRouteRoute$Outbound;
  position?: Position$Outbound | undefined;
};

/** @internal */
export const AddRouteRequestBody$outboundSchema: z.ZodType<
  AddRouteRequestBody$Outbound,
  z.ZodTypeDef,
  AddRouteRequestBody
> = z.object({
  route: z.lazy(() => AddRouteRoute$outboundSchema),
  position: z.lazy(() => Position$outboundSchema).optional(),
});

export function addRouteRequestBodyToJSON(
  addRouteRequestBody: AddRouteRequestBody,
): string {
  return JSON.stringify(
    AddRouteRequestBody$outboundSchema.parse(addRouteRequestBody),
  );
}

/** @internal */
export type AddRouteRequest$Outbound = {
  projectId: string;
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody?: AddRouteRequestBody$Outbound | undefined;
};

/** @internal */
export const AddRouteRequest$outboundSchema: z.ZodType<
  AddRouteRequest$Outbound,
  z.ZodTypeDef,
  AddRouteRequest
> = z.object({
  projectId: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.lazy(() => AddRouteRequestBody$outboundSchema).optional(),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function addRouteRequestToJSON(
  addRouteRequest: AddRouteRequest,
): string {
  return JSON.stringify(AddRouteRequest$outboundSchema.parse(addRouteRequest));
}

/** @internal */
export const RouteType$inboundSchema: z.ZodNativeEnum<typeof RouteType> = z
  .nativeEnum(RouteType);

/** @internal */
export const AddRouteHasProjectRoutesType$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteHasProjectRoutesType
> = z.nativeEnum(AddRouteHasProjectRoutesType);

/** @internal */
export const AddRouteValueProjectRoutesEq$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutesEq,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), types.number()]);

export function addRouteValueProjectRoutesEqFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueProjectRoutesEq, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteValueProjectRoutesEq$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueProjectRoutesEq' from JSON`,
  );
}

/** @internal */
export const AddRouteValueProjectRoutes2$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutes2,
  z.ZodTypeDef,
  unknown
> = z.object({
  eq: types.optional(smartUnion([types.string(), types.number()])),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  re: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

export function addRouteValueProjectRoutes2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueProjectRoutes2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteValueProjectRoutes2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueProjectRoutes2' from JSON`,
  );
}

/** @internal */
export const AddRouteHasProjectRoutesValue$inboundSchema: z.ZodType<
  AddRouteHasProjectRoutesValue,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  types.string(),
  z.lazy(() => AddRouteValueProjectRoutes2$inboundSchema),
]);

export function addRouteHasProjectRoutesValueFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteHasProjectRoutesValue, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteHasProjectRoutesValue$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteHasProjectRoutesValue' from JSON`,
  );
}

/** @internal */
export const AddRouteHas2$inboundSchema: z.ZodType<
  AddRouteHas2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: AddRouteHasProjectRoutesType$inboundSchema,
  key: types.string(),
  value: types.optional(
    smartUnion([
      types.string(),
      z.lazy(() => AddRouteValueProjectRoutes2$inboundSchema),
    ]),
  ),
});

export function addRouteHas2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteHas2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteHas2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteHas2' from JSON`,
  );
}

/** @internal */
export const AddRouteValueEq$inboundSchema: z.ZodType<
  AddRouteValueEq,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), types.number()]);

export function addRouteValueEqFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueEq, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteValueEq$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueEq' from JSON`,
  );
}

/** @internal */
export const AddRouteValue2$inboundSchema: z.ZodType<
  AddRouteValue2,
  z.ZodTypeDef,
  unknown
> = z.object({
  eq: types.optional(smartUnion([types.string(), types.number()])),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  re: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

export function addRouteValue2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValue2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteValue2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValue2' from JSON`,
  );
}

/** @internal */
export const AddRouteHasValue$inboundSchema: z.ZodType<
  AddRouteHasValue,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), z.lazy(() => AddRouteValue2$inboundSchema)]);

export function addRouteHasValueFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteHasValue, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteHasValue$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteHasValue' from JSON`,
  );
}

/** @internal */
export const AddRouteHas1$inboundSchema: z.ZodType<
  AddRouteHas1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("host"),
  value: smartUnion([
    types.string(),
    z.lazy(() => AddRouteValue2$inboundSchema),
  ]),
});

export function addRouteHas1FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteHas1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteHas1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteHas1' from JSON`,
  );
}

/** @internal */
export const AddRouteProjectRoutesHas$inboundSchema: z.ZodType<
  AddRouteProjectRoutesHas,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => AddRouteHas1$inboundSchema),
  z.lazy(() => AddRouteHas2$inboundSchema).and(
    z.object({ type: z.literal("cookie") }),
  ),
  z.lazy(() => AddRouteHas2$inboundSchema).and(
    z.object({ type: z.literal("header") }),
  ),
  z.lazy(() => AddRouteHas2$inboundSchema).and(
    z.object({ type: z.literal("query") }),
  ),
]);

export function addRouteProjectRoutesHasFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteProjectRoutesHas, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteProjectRoutesHas$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteProjectRoutesHas' from JSON`,
  );
}

/** @internal */
export const AddRouteMissingProjectRoutesType$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteMissingProjectRoutesType
> = z.nativeEnum(AddRouteMissingProjectRoutesType);

/** @internal */
export const AddRouteValueProjectRoutesResponse200Eq$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutesResponse200Eq,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), types.number()]);

export function addRouteValueProjectRoutesResponse200EqFromJSON(
  jsonString: string,
): SafeParseResult<
  AddRouteValueProjectRoutesResponse200Eq,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteValueProjectRoutesResponse200Eq$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'AddRouteValueProjectRoutesResponse200Eq' from JSON`,
  );
}

/** @internal */
export const AddRouteValueProjectRoutesResponse2002$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutesResponse2002,
  z.ZodTypeDef,
  unknown
> = z.object({
  eq: types.optional(smartUnion([types.string(), types.number()])),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  re: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

export function addRouteValueProjectRoutesResponse2002FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueProjectRoutesResponse2002, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteValueProjectRoutesResponse2002$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueProjectRoutesResponse2002' from JSON`,
  );
}

/** @internal */
export const AddRouteMissingProjectRoutesValue$inboundSchema: z.ZodType<
  AddRouteMissingProjectRoutesValue,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  types.string(),
  z.lazy(() => AddRouteValueProjectRoutesResponse2002$inboundSchema),
]);

export function addRouteMissingProjectRoutesValueFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteMissingProjectRoutesValue, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteMissingProjectRoutesValue$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteMissingProjectRoutesValue' from JSON`,
  );
}

/** @internal */
export const AddRouteMissing2$inboundSchema: z.ZodType<
  AddRouteMissing2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: AddRouteMissingProjectRoutesType$inboundSchema,
  key: types.string(),
  value: types.optional(
    smartUnion([
      types.string(),
      z.lazy(() => AddRouteValueProjectRoutesResponse2002$inboundSchema),
    ]),
  ),
});

export function addRouteMissing2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteMissing2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteMissing2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteMissing2' from JSON`,
  );
}

/** @internal */
export const AddRouteValueProjectRoutesResponseEq$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutesResponseEq,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), types.number()]);

export function addRouteValueProjectRoutesResponseEqFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueProjectRoutesResponseEq, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteValueProjectRoutesResponseEq$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueProjectRoutesResponseEq' from JSON`,
  );
}

/** @internal */
export const AddRouteValueProjectRoutesResponse2$inboundSchema: z.ZodType<
  AddRouteValueProjectRoutesResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  eq: types.optional(smartUnion([types.string(), types.number()])),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  re: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

export function addRouteValueProjectRoutesResponse2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteValueProjectRoutesResponse2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteValueProjectRoutesResponse2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteValueProjectRoutesResponse2' from JSON`,
  );
}

/** @internal */
export const AddRouteMissingValue$inboundSchema: z.ZodType<
  AddRouteMissingValue,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  types.string(),
  z.lazy(() => AddRouteValueProjectRoutesResponse2$inboundSchema),
]);

export function addRouteMissingValueFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteMissingValue, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteMissingValue$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteMissingValue' from JSON`,
  );
}

/** @internal */
export const AddRouteMissing1$inboundSchema: z.ZodType<
  AddRouteMissing1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("host"),
  value: smartUnion([
    types.string(),
    z.lazy(() => AddRouteValueProjectRoutesResponse2$inboundSchema),
  ]),
});

export function addRouteMissing1FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteMissing1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteMissing1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteMissing1' from JSON`,
  );
}

/** @internal */
export const AddRouteProjectRoutesMissing$inboundSchema: z.ZodType<
  AddRouteProjectRoutesMissing,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => AddRouteMissing1$inboundSchema),
  z.lazy(() => AddRouteMissing2$inboundSchema).and(
    z.object({ type: z.literal("cookie") }),
  ),
  z.lazy(() => AddRouteMissing2$inboundSchema).and(
    z.object({ type: z.literal("header") }),
  ),
  z.lazy(() => AddRouteMissing2$inboundSchema).and(
    z.object({ type: z.literal("query") }),
  ),
]);

export function addRouteProjectRoutesMissingFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteProjectRoutesMissing, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteProjectRoutesMissing$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteProjectRoutesMissing' from JSON`,
  );
}

/** @internal */
export const AddRouteAction$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteAction
> = z.nativeEnum(AddRouteAction);

/** @internal */
export const AddRouteMitigate$inboundSchema: z.ZodType<
  AddRouteMitigate,
  z.ZodTypeDef,
  unknown
> = z.object({
  action: AddRouteAction$inboundSchema,
});

export function addRouteMitigateFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteMitigate, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteMitigate$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteMitigate' from JSON`,
  );
}

/** @internal */
export const AddRouteTransformsProjectRoutesOp$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteTransformsProjectRoutesOp
> = z.nativeEnum(AddRouteTransformsProjectRoutesOp);

/** @internal */
export const AddRouteTransforms2$inboundSchema: z.ZodType<
  AddRouteTransforms2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("request.path"),
  op: AddRouteTransformsProjectRoutesOp$inboundSchema,
  args: types.string(),
  env: types.optional(z.array(types.string())),
});

export function addRouteTransforms2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteTransforms2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteTransforms2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteTransforms2' from JSON`,
  );
}

/** @internal */
export const AddRouteTransformsType$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteTransformsType
> = z.nativeEnum(AddRouteTransformsType);

/** @internal */
export const AddRouteTransformsOp$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteTransformsOp
> = z.nativeEnum(AddRouteTransformsOp);

/** @internal */
export const AddRouteKeyEq$inboundSchema: z.ZodType<
  AddRouteKeyEq,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), types.number()]);

export function addRouteKeyEqFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteKeyEq, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteKeyEq$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteKeyEq' from JSON`,
  );
}

/** @internal */
export const AddRouteKey2$inboundSchema: z.ZodType<
  AddRouteKey2,
  z.ZodTypeDef,
  unknown
> = z.object({
  eq: types.optional(smartUnion([types.string(), types.number()])),
  neq: types.optional(types.string()),
  inc: types.optional(z.array(types.string())),
  ninc: types.optional(z.array(types.string())),
  pre: types.optional(types.string()),
  suf: types.optional(types.string()),
  gt: types.optional(types.number()),
  gte: types.optional(types.number()),
  lt: types.optional(types.number()),
  lte: types.optional(types.number()),
});

export function addRouteKey2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteKey2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteKey2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteKey2' from JSON`,
  );
}

/** @internal */
export const TransformsKey$inboundSchema: z.ZodType<
  TransformsKey,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), z.lazy(() => AddRouteKey2$inboundSchema)]);

export function transformsKeyFromJSON(
  jsonString: string,
): SafeParseResult<TransformsKey, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => TransformsKey$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'TransformsKey' from JSON`,
  );
}

/** @internal */
export const AddRouteTransformsTarget$inboundSchema: z.ZodType<
  AddRouteTransformsTarget,
  z.ZodTypeDef,
  unknown
> = z.object({
  key: smartUnion([types.string(), z.lazy(() => AddRouteKey2$inboundSchema)]),
});

export function addRouteTransformsTargetFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteTransformsTarget, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteTransformsTarget$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteTransformsTarget' from JSON`,
  );
}

/** @internal */
export const TransformsArgs$inboundSchema: z.ZodType<
  TransformsArgs,
  z.ZodTypeDef,
  unknown
> = smartUnion([types.string(), z.array(types.string())]);

export function transformsArgsFromJSON(
  jsonString: string,
): SafeParseResult<TransformsArgs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => TransformsArgs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'TransformsArgs' from JSON`,
  );
}

/** @internal */
export const AddRouteTransforms1$inboundSchema: z.ZodType<
  AddRouteTransforms1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: AddRouteTransformsType$inboundSchema,
  op: AddRouteTransformsOp$inboundSchema,
  target: z.lazy(() => AddRouteTransformsTarget$inboundSchema),
  args: types.optional(smartUnion([types.string(), z.array(types.string())])),
  env: types.optional(z.array(types.string())),
});

export function addRouteTransforms1FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteTransforms1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteTransforms1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteTransforms1' from JSON`,
  );
}

/** @internal */
export const AddRouteProjectRoutesTransforms$inboundSchema: z.ZodType<
  AddRouteProjectRoutesTransforms,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => AddRouteTransforms1$inboundSchema).and(
    z.object({ type: z.literal("request.headers") }),
  ),
  z.lazy(() => AddRouteTransforms1$inboundSchema).and(
    z.object({ type: z.literal("request.query") }),
  ),
  z.lazy(() => AddRouteTransforms1$inboundSchema).and(
    z.object({ type: z.literal("response.headers") }),
  ),
  z.lazy(() => AddRouteTransforms2$inboundSchema),
]);

export function addRouteProjectRoutesTransformsFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteProjectRoutesTransforms, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteProjectRoutesTransforms$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteProjectRoutesTransforms' from JSON`,
  );
}

/** @internal */
export const AddRouteLocale$inboundSchema: z.ZodType<
  AddRouteLocale,
  z.ZodTypeDef,
  unknown
> = z.object({
  redirect: types.optional(z.record(types.string())),
  cookie: types.optional(types.string()),
});

export function addRouteLocaleFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteLocale, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteLocale$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteLocale' from JSON`,
  );
}

/** @internal */
export const AddRouteDestinationType$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteDestinationType
> = z.nativeEnum(AddRouteDestinationType);

/** @internal */
export const AddRouteDestination2$inboundSchema: z.ZodType<
  AddRouteDestination2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.optional(AddRouteDestinationType$inboundSchema),
  service: types.string(),
  path: types.optional(types.string()),
});

export function addRouteDestination2FromJSON(
  jsonString: string,
): SafeParseResult<AddRouteDestination2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteDestination2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteDestination2' from JSON`,
  );
}

/** @internal */
export const AddRouteDestination$inboundSchema: z.ZodType<
  AddRouteDestination,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => AddRouteDestination2$inboundSchema),
  types.string(),
]);

export function addRouteDestinationFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteDestination, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteDestination$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteDestination' from JSON`,
  );
}

/** @internal */
export const AddRouteProjectRoutesResponse200Route$inboundSchema: z.ZodType<
  AddRouteProjectRoutesResponse200Route,
  z.ZodTypeDef,
  unknown
> = z.object({
  src: types.string(),
  dest: types.optional(types.string()),
  headers: types.optional(z.record(types.string())),
  methods: types.optional(z.array(types.string())),
  continue: types.optional(types.boolean()),
  override: types.optional(types.boolean()),
  caseSensitive: types.optional(types.boolean()),
  check: types.optional(types.boolean()),
  important: types.optional(types.boolean()),
  status: types.optional(types.number()),
  has: types.optional(
    z.array(z.union([
      z.lazy(() => AddRouteHas1$inboundSchema),
      z.lazy(() =>
        AddRouteHas2$inboundSchema
      ).and(z.object({ type: z.literal("cookie") })),
      z.lazy(() => AddRouteHas2$inboundSchema).and(
        z.object({ type: z.literal("header") }),
      ),
      z.lazy(() => AddRouteHas2$inboundSchema).and(
        z.object({ type: z.literal("query") }),
      ),
    ])),
  ),
  missing: types.optional(
    z.array(z.union([
      z.lazy(() => AddRouteMissing1$inboundSchema),
      z.lazy(() =>
        AddRouteMissing2$inboundSchema
      ).and(z.object({ type: z.literal("cookie") })),
      z.lazy(() => AddRouteMissing2$inboundSchema).and(
        z.object({ type: z.literal("header") }),
      ),
      z.lazy(() => AddRouteMissing2$inboundSchema).and(
        z.object({ type: z.literal("query") }),
      ),
    ])),
  ),
  mitigate: types.optional(z.lazy(() => AddRouteMitigate$inboundSchema)),
  transforms: types.optional(
    z.array(z.union([
      z.lazy(() => AddRouteTransforms1$inboundSchema).and(
        z.object({ type: z.literal("request.headers") }),
      ),
      z.lazy(() => AddRouteTransforms1$inboundSchema).and(
        z.object({ type: z.literal("request.query") }),
      ),
      z.lazy(() => AddRouteTransforms1$inboundSchema).and(
        z.object({ type: z.literal("response.headers") }),
      ),
      z.lazy(() => AddRouteTransforms2$inboundSchema),
    ])),
  ),
  env: types.optional(z.array(types.string())),
  locale: types.optional(z.lazy(() => AddRouteLocale$inboundSchema)),
  source: types.optional(types.string()),
  destination: types.optional(
    smartUnion([
      z.lazy(() => AddRouteDestination2$inboundSchema),
      types.string(),
    ]),
  ),
  statusCode: types.optional(types.number()),
  middlewarePath: types.optional(types.string()),
  middlewareRawSrc: types.optional(z.array(types.string())),
  middleware: types.optional(types.number()),
  respectOriginCacheControl: types.optional(types.boolean()),
});

export function addRouteProjectRoutesResponse200RouteFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteProjectRoutesResponse200Route, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteProjectRoutesResponse200Route$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteProjectRoutesResponse200Route' from JSON`,
  );
}

/** @internal */
export const AddRouteSrcSyntax$inboundSchema: z.ZodNativeEnum<
  typeof AddRouteSrcSyntax
> = z.nativeEnum(AddRouteSrcSyntax);

/** @internal */
export const AddRouteProjectRoutesResponseRoute$inboundSchema: z.ZodType<
  AddRouteProjectRoutesResponseRoute,
  z.ZodTypeDef,
  unknown
> = z.object({
  routeType: types.optional(RouteType$inboundSchema),
  id: types.string(),
  name: types.string(),
  description: types.optional(types.string()),
  enabled: types.optional(types.boolean()),
  staged: types.optional(types.boolean()),
  route: z.lazy(() => AddRouteProjectRoutesResponse200Route$inboundSchema),
  rawSrc: types.optional(types.string()),
  rawDest: types.optional(types.string()),
  srcSyntax: types.optional(AddRouteSrcSyntax$inboundSchema),
});

export function addRouteProjectRoutesResponseRouteFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteProjectRoutesResponseRoute, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      AddRouteProjectRoutesResponseRoute$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteProjectRoutesResponseRoute' from JSON`,
  );
}

/** @internal */
export const AddRouteVersion$inboundSchema: z.ZodType<
  AddRouteVersion,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  s3Key: types.string(),
  lastModified: types.number(),
  createdBy: types.string(),
  isStaging: types.optional(types.boolean()),
  isLive: types.optional(types.boolean()),
  ruleCount: types.optional(types.number()),
  alias: types.optional(types.string()),
});

export function addRouteVersionFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteVersion, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteVersion$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteVersion' from JSON`,
  );
}

/** @internal */
export const AddRouteResponseBody$inboundSchema: z.ZodType<
  AddRouteResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  route: z.lazy(() => AddRouteProjectRoutesResponseRoute$inboundSchema),
  version: z.lazy(() => AddRouteVersion$inboundSchema),
});

export function addRouteResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<AddRouteResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AddRouteResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AddRouteResponseBody' from JSON`,
  );
}