/*
 * 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 { ACLAction, ACLAction$inboundSchema } from "./aclaction.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export type UpdateMicrofrontendsRequestBody = {
  /**
   * The unique group identifier to add this microfrontend to
   */
  microfrontendsGroupId?: string | undefined;
  /**
   * Enable or disable microfrontends for the project
   */
  enabled?: boolean | undefined;
  /**
   * Whether the application is the default application for the microfrontends group
   */
  isDefaultApp?: boolean | undefined;
  /**
   * The default route used for screenshots and preview links for the project
   */
  defaultRoute?: string | undefined;
  /**
   * Whether observability data should be routed to this project or a root project. Can only be set for child applications.
   */
  routeObservabilityToThisProject?: boolean | undefined;
  /**
   * Whether domains in this project should route as a microfrontend. Can only be set for child applications.
   */
  doNotRouteWithMicrofrontendsRouting?: boolean | undefined;
};

export type UpdateMicrofrontendsRequest = {
  /**
   * The unique project identifier
   */
  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?: UpdateMicrofrontendsRequestBody | undefined;
};

export type UpdateMicrofrontendsAnalytics = {
  id: string;
  canceledAt?: number | null | undefined;
  disabledAt: number;
  enabledAt: number;
  paidAt?: number | undefined;
  sampleRatePercent?: number | null | undefined;
  spendLimitInDollars?: number | null | undefined;
};

export type UpdateMicrofrontendsSpeedInsights = {
  id: string;
  enabledAt?: number | undefined;
  disabledAt?: number | undefined;
  canceledAt?: number | undefined;
  hasData?: boolean | undefined;
  paidAt?: number | undefined;
};

export const UpdateMicrofrontendsEnvId2 = {
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateMicrofrontendsEnvId2 = ClosedEnum<
  typeof UpdateMicrofrontendsEnvId2
>;

export type UpdateMicrofrontendsEnvId = string | UpdateMicrofrontendsEnvId2;

export type UpdateMicrofrontendsAws = {
  subnetIds: Array<string>;
  securityGroupId?: string | undefined;
};

export type UpdateMicrofrontendsConnectConfigurations = {
  envId: string | UpdateMicrofrontendsEnvId2;
  connectConfigurationId: string;
  dc?: string | undefined;
  passive: boolean;
  buildsEnabled: boolean;
  aws?: UpdateMicrofrontendsAws | undefined;
  createdAt: number;
  updatedAt: number;
};

/**
 * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
 */
export const UpdateMicrofrontendsSource = {
  Api: "api",
} as const;
/**
 * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
 */
export type UpdateMicrofrontendsSource = ClosedEnum<
  typeof UpdateMicrofrontendsSource
>;

export type UpdateMicrofrontendsDefinitions = {
  /**
   * The hostname that should be used.
   */
  host: string;
  /**
   * The path that should be called for the cronjob.
   */
  path: string;
  /**
   * The cron expression.
   */
  schedule: string;
  /**
   * The origin of this definition. 'api' means created via the API. Undefined means it originated from a deployment (vercel.json).
   */
  source?: UpdateMicrofrontendsSource | undefined;
  /**
   * A human-readable description of what this cron job does.
   */
  description?: string | undefined;
  /**
   * Whether the host was inferred from the production deployment URL rather than explicitly provided.
   */
  hostInferred?: boolean | undefined;
};

export type UpdateMicrofrontendsCrons = {
  /**
   * The time the feature was enabled for this project. Note: It enables automatically with the first Deployment that outputs cronjobs.
   */
  enabledAt: number;
  /**
   * The time the feature was disabled for this project.
   */
  disabledAt: number | null;
  updatedAt: number;
  /**
   * The ID of the Deployment from which the definitions originated.
   */
  deploymentId: string | null;
  definitions: Array<UpdateMicrofrontendsDefinitions>;
};

export type UpdateMicrofrontendsDataCache = {
  userDisabled: boolean;
  storageSizeBytes?: number | null | undefined;
  unlimited?: boolean | undefined;
};

/**
 * Retention policies for deployments. These are enforced at the project level, but we also maintain an instance of this at the team level as a default policy that gets applied to new projects.
 */
export type UpdateMicrofrontendsDeploymentExpiration = {
  /**
   * Number of days to keep non-production deployments (mostly preview deployments) before soft deletion.
   */
  expirationDays?: number | undefined;
  /**
   * Number of days to keep production deployments before soft deletion.
   */
  expirationDaysProduction?: number | undefined;
  /**
   * Number of days to keep canceled deployments before soft deletion.
   */
  expirationDaysCanceled?: number | undefined;
  /**
   * Number of days to keep errored deployments before soft deletion.
   */
  expirationDaysErrored?: number | undefined;
  /**
   * Minimum number of production deployments to keep for this project, even if they are over the production expiration limit.
   */
  deploymentsToKeep?: number | undefined;
};

export type UpdateMicrofrontendsExpiration2 = {
  /**
   * Unix ms timestamp when the project was locked.
   */
  lockedAt: number;
  /**
   * userId of the actor that triggered the lock (system or admin).
   */
  lockedBy: string;
};

export type UpdateMicrofrontendsExpiration1 = {
  /**
   * Unix ms timestamp when the project is scheduled to expire.
   */
  expiresAt: number;
};

export type UpdateMicrofrontendsExpiration =
  | UpdateMicrofrontendsExpiration2
  | UpdateMicrofrontendsExpiration1;

export const UpdateMicrofrontendsTarget2 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateMicrofrontendsTarget2 = ClosedEnum<
  typeof UpdateMicrofrontendsTarget2
>;

export const UpdateMicrofrontendsTarget1 = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
export type UpdateMicrofrontendsTarget1 = ClosedEnum<
  typeof UpdateMicrofrontendsTarget1
>;

export type UpdateMicrofrontendsTarget =
  | Array<UpdateMicrofrontendsTarget1>
  | UpdateMicrofrontendsTarget2;

export const UpdateMicrofrontendsType = {
  Encrypted: "encrypted",
  Plain: "plain",
  Secret: "secret",
  Sensitive: "sensitive",
  System: "system",
} as const;
export type UpdateMicrofrontendsType = ClosedEnum<
  typeof UpdateMicrofrontendsType
>;

export type UpdateMicrofrontendsContentHint17 = {
  type: "flags-connection-string";
  projectId: string;
};

export type UpdateMicrofrontendsContentHint16 = {
  type: "integration-store-secret";
  storeId: string;
  integrationId: string;
  integrationProductId: string;
  integrationConfigurationId: string;
};

export type UpdateMicrofrontendsContentHint15 = {
  type: "postgres-url-no-ssl";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint14 = {
  type: "postgres-database";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint13 = {
  type: "postgres-password";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint12 = {
  type: "postgres-host";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint11 = {
  type: "postgres-user";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint10 = {
  type: "postgres-prisma-url";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint9 = {
  type: "postgres-url-non-pooling";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint8 = {
  type: "postgres-url";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint7 = {
  type: "blob-webhook-public-key";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint6 = {
  type: "blob-store-id";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint5 = {
  type: "blob-read-write-token";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint4 = {
  type: "redis-rest-api-read-only-token";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint3 = {
  type: "redis-rest-api-token";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint2 = {
  type: "redis-rest-api-url";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint1 = {
  type: "redis-url";
  storeId: string;
};

export type UpdateMicrofrontendsContentHint =
  | UpdateMicrofrontendsContentHint1
  | UpdateMicrofrontendsContentHint2
  | UpdateMicrofrontendsContentHint3
  | UpdateMicrofrontendsContentHint4
  | UpdateMicrofrontendsContentHint5
  | UpdateMicrofrontendsContentHint6
  | UpdateMicrofrontendsContentHint7
  | UpdateMicrofrontendsContentHint8
  | UpdateMicrofrontendsContentHint9
  | UpdateMicrofrontendsContentHint10
  | UpdateMicrofrontendsContentHint11
  | UpdateMicrofrontendsContentHint12
  | UpdateMicrofrontendsContentHint13
  | UpdateMicrofrontendsContentHint14
  | UpdateMicrofrontendsContentHint15
  | UpdateMicrofrontendsContentHint16
  | UpdateMicrofrontendsContentHint17;

export const UpdateMicrofrontendsProjectsResponse200ApplicationJSONType = {
  FlagsSecret: "flags-secret",
} as const;
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONType =
  ClosedEnum<typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONType>;

/**
 * Similar to `contentHints`, but should not be exposed to the user.
 */
export type UpdateMicrofrontendsInternalContentHint = {
  type: UpdateMicrofrontendsProjectsResponse200ApplicationJSONType;
  /**
   * Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
   */
  encryptedValue: string;
};

export type UpdateMicrofrontendsEnv = {
  target?:
    | Array<UpdateMicrofrontendsTarget1>
    | UpdateMicrofrontendsTarget2
    | undefined;
  type: UpdateMicrofrontendsType;
  /**
   * This is used to identify variables that have been migrated from type secret to sensitive.
   */
  sunsetSecretId?: string | undefined;
  /**
   * Legacy now-encryption ciphertext, present after migration swaps value/vsmValue
   */
  legacyValue?: string | undefined;
  decrypted?: boolean | undefined;
  value: string;
  vsmValue?: string | undefined;
  id?: string | undefined;
  key: string;
  configurationId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  gitBranch?: string | undefined;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  contentHint?:
    | UpdateMicrofrontendsContentHint1
    | UpdateMicrofrontendsContentHint2
    | UpdateMicrofrontendsContentHint3
    | UpdateMicrofrontendsContentHint4
    | UpdateMicrofrontendsContentHint5
    | UpdateMicrofrontendsContentHint6
    | UpdateMicrofrontendsContentHint7
    | UpdateMicrofrontendsContentHint8
    | UpdateMicrofrontendsContentHint9
    | UpdateMicrofrontendsContentHint10
    | UpdateMicrofrontendsContentHint11
    | UpdateMicrofrontendsContentHint12
    | UpdateMicrofrontendsContentHint13
    | UpdateMicrofrontendsContentHint14
    | UpdateMicrofrontendsContentHint15
    | UpdateMicrofrontendsContentHint16
    | UpdateMicrofrontendsContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | UpdateMicrofrontendsInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

/**
 * The type of environment (production, preview, or development)
 */
export const UpdateMicrofrontendsProjectsType = {
  Development: "development",
  Preview: "preview",
  Production: "production",
} as const;
/**
 * The type of environment (production, preview, or development)
 */
export type UpdateMicrofrontendsProjectsType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsType
>;

/**
 * The type of matching to perform
 */
export const UpdateMicrofrontendsProjectsResponse200Type = {
  EndsWith: "endsWith",
  Equals: "equals",
  StartsWith: "startsWith",
} as const;
/**
 * The type of matching to perform
 */
export type UpdateMicrofrontendsProjectsResponse200Type = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponse200Type
>;

/**
 * Configuration for matching git branches to this environment
 */
export type UpdateMicrofrontendsBranchMatcher = {
  /**
   * The type of matching to perform
   */
  type: UpdateMicrofrontendsProjectsResponse200Type;
  /**
   * The pattern to match against branch names
   */
  pattern: string;
};

/**
 * A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
 */
export type UpdateMicrofrontendsVerification = {
  type: string;
  domain: string;
  value: string;
  reason: string;
};

/**
 * List of domains associated with this environment
 */
export type UpdateMicrofrontendsDomains = {
  name: string;
  apexName: string;
  projectId: string;
  redirect?: string | null | undefined;
  redirectStatusCode?: number | null | undefined;
  gitBranch?: string | null | undefined;
  customEnvironmentId?: string | null | undefined;
  updatedAt?: number | undefined;
  createdAt?: number | undefined;
  /**
   * `true` if the domain is verified for use with the project. If `false` it will not be used as an alias on this project until the challenge in `verification` is completed.
   */
  verified: boolean;
  /**
   * A list of verification challenges, one of which must be completed to verify the domain for use on the project. After the challenge is complete `POST /projects/:idOrName/domains/:domain/verify` to verify the domain. Possible challenges: - If `verification.type = TXT` the `verification.domain` will be checked for a TXT record matching `verification.value`.
   */
  verification?: Array<UpdateMicrofrontendsVerification> | undefined;
};

/**
 * Internal representation of a custom environment with all required properties
 */
export type UpdateMicrofrontendsCustomEnvironments = {
  /**
   * Unique identifier for the custom environment (format: env_*)
   */
  id: string;
  /**
   * URL-friendly name of the environment
   */
  slug: string;
  /**
   * The type of environment (production, preview, or development)
   */
  type: UpdateMicrofrontendsProjectsType;
  /**
   * Optional description of the environment's purpose
   */
  description?: string | undefined;
  /**
   * Configuration for matching git branches to this environment
   */
  branchMatcher?: UpdateMicrofrontendsBranchMatcher | undefined;
  /**
   * List of domains associated with this environment
   */
  domains?: Array<UpdateMicrofrontendsDomains> | undefined;
  /**
   * List of aliases for the current deployment
   */
  currentDeploymentAliases?: Array<string> | undefined;
  /**
   * Timestamp when the environment was created
   */
  createdAt: number;
  /**
   * Timestamp when the environment was last updated
   */
  updatedAt: number;
};

export const UpdateMicrofrontendsFramework = {
  ActixWeb: "actix-web",
  Angular: "angular",
  Ash: "ash",
  Astro: "astro",
  Axum: "axum",
  Blitzjs: "blitzjs",
  Brunch: "brunch",
  Bun: "bun",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  Fastapi: "fastapi",
  Fasthtml: "fasthtml",
  Fastify: "fastify",
  Flask: "flask",
  Gatsby: "gatsby",
  Go: "go",
  Gridsome: "gridsome",
  H3: "h3",
  Hexo: "hexo",
  Hono: "hono",
  Hugo: "hugo",
  Hydrogen: "hydrogen",
  IonicAngular: "ionic-angular",
  IonicReact: "ionic-react",
  Jekyll: "jekyll",
  Koa: "koa",
  Mastra: "mastra",
  Middleman: "middleman",
  Nestjs: "nestjs",
  Nextjs: "nextjs",
  Nitro: "nitro",
  Node: "node",
  Nuxtjs: "nuxtjs",
  Parcel: "parcel",
  Polymer: "polymer",
  Preact: "preact",
  Python: "python",
  ReactRouter: "react-router",
  Redwoodjs: "redwoodjs",
  Remix: "remix",
  Ruby: "ruby",
  Rust: "rust",
  Saber: "saber",
  Sanity: "sanity",
  SanityV2: "sanity-v2",
  Sapper: "sapper",
  Scully: "scully",
  Services: "services",
  Solidstart: "solidstart",
  Solidstart1: "solidstart-1",
  Stencil: "stencil",
  Storybook: "storybook",
  Svelte: "svelte",
  Sveltekit: "sveltekit",
  Sveltekit1: "sveltekit-1",
  TanstackStart: "tanstack-start",
  Umijs: "umijs",
  Vite: "vite",
  Vitepress: "vitepress",
  Vue: "vue",
  Vuepress: "vuepress",
  Xmcp: "xmcp",
  Zola: "zola",
} as const;
export type UpdateMicrofrontendsFramework = ClosedEnum<
  typeof UpdateMicrofrontendsFramework
>;

/**
 * Service kind (Service.type). Omitted for schemas that do not define one.
 */
export const UpdateMicrofrontendsServiceType = {
  Cron: "cron",
  Job: "job",
  Web: "web",
  Worker: "worker",
} as const;
/**
 * Service kind (Service.type). Omitted for schemas that do not define one.
 */
export type UpdateMicrofrontendsServiceType = ClosedEnum<
  typeof UpdateMicrofrontendsServiceType
>;

/**
 * Framework slug, when the service has one (omitted otherwise).
 */
export const UpdateMicrofrontendsProjectsFramework = {
  ActixWeb: "actix-web",
  Angular: "angular",
  Ash: "ash",
  Astro: "astro",
  Axum: "axum",
  Blitzjs: "blitzjs",
  Brunch: "brunch",
  Bun: "bun",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  Fastapi: "fastapi",
  Fasthtml: "fasthtml",
  Fastify: "fastify",
  Flask: "flask",
  Gatsby: "gatsby",
  Go: "go",
  Gridsome: "gridsome",
  H3: "h3",
  Hexo: "hexo",
  Hono: "hono",
  Hugo: "hugo",
  Hydrogen: "hydrogen",
  IonicAngular: "ionic-angular",
  IonicReact: "ionic-react",
  Jekyll: "jekyll",
  Koa: "koa",
  Mastra: "mastra",
  Middleman: "middleman",
  Nestjs: "nestjs",
  Nextjs: "nextjs",
  Nitro: "nitro",
  Node: "node",
  Nuxtjs: "nuxtjs",
  Parcel: "parcel",
  Polymer: "polymer",
  Preact: "preact",
  Python: "python",
  ReactRouter: "react-router",
  Redwoodjs: "redwoodjs",
  Remix: "remix",
  Ruby: "ruby",
  Rust: "rust",
  Saber: "saber",
  Sanity: "sanity",
  SanityV2: "sanity-v2",
  Sapper: "sapper",
  Scully: "scully",
  Services: "services",
  Solidstart: "solidstart",
  Solidstart1: "solidstart-1",
  Stencil: "stencil",
  Storybook: "storybook",
  Svelte: "svelte",
  Sveltekit: "sveltekit",
  Sveltekit1: "sveltekit-1",
  TanstackStart: "tanstack-start",
  Umijs: "umijs",
  Vite: "vite",
  Vitepress: "vitepress",
  Vue: "vue",
  Vuepress: "vuepress",
  Xmcp: "xmcp",
  Zola: "zola",
} as const;
/**
 * Framework slug, when the service has one (omitted otherwise).
 */
export type UpdateMicrofrontendsProjectsFramework = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsFramework
>;

export type UpdateMicrofrontendsServices = {
  /**
   * Service name from the deployment (Service.name).
   */
  serviceName: string;
  /**
   * Service kind (Service.type). Omitted for schemas that do not define one.
   */
  serviceType?: UpdateMicrofrontendsServiceType | undefined;
  /**
   * Framework slug, when the service has one (omitted otherwise).
   */
  framework?: UpdateMicrofrontendsProjectsFramework | undefined;
  /**
   * Generic runtime, e.g. 'node' | 'python' | 'go' | 'ruby' | 'rust' (Service.runtime). Omitted for static builds.
   */
  runtime?: string | undefined;
};

export type UpdateMicrofrontendsIpBuckets = {
  bucket: string;
  default?: boolean | undefined;
  supportUntil?: number | undefined;
};

export type UpdateMicrofrontendsLint = {
  targets: Array<string>;
};

export type UpdateMicrofrontendsTypecheck = {
  targets: Array<string>;
};

export type UpdateMicrofrontendsMfeConfigPresent = {
  targets: Array<string>;
};

export type UpdateMicrofrontendsJobs = {
  lint?: UpdateMicrofrontendsLint | undefined;
  typecheck?: UpdateMicrofrontendsTypecheck | undefined;
  mfeConfigPresent?: UpdateMicrofrontendsMfeConfigPresent | undefined;
};

export type UpdateMicrofrontendsAliasAssigned = number | boolean;

export type UpdateMicrofrontendsBuilds = {
  use: string;
  src?: string | undefined;
  dest?: string | undefined;
};

export type UpdateMicrofrontendsCreator = {
  email: string;
  githubLogin?: string | undefined;
  gitlabLogin?: string | undefined;
  uid: string;
  username: string;
};

export type UpdateMicrofrontendsLatestDeployments = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<UpdateMicrofrontendsBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: UpdateMicrofrontendsCreator | null;
  deploymentHostname: string;
  name: string;
  forced?: boolean | undefined;
  id: string;
  meta?: { [k: string]: string } | undefined;
  plan: string;
  private: boolean;
  readyState: string;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: string;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

export type UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks =
  {
    createdAt?: number | undefined;
    id: string;
    name: string;
    ref: string;
    url: string;
  };

export type UpdateMicrofrontendsLink6 = {
  org: string;
  repo: string;
  type: "vercel";
  createdAt?: number | undefined;
  deployHooks: Array<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONDeployHooks =
  {
    createdAt?: number | undefined;
    id: string;
    name: string;
    ref: string;
    url: string;
  };

export type UpdateMicrofrontendsLink5 = {
  name: string;
  slug: string;
  owner: string;
  type: "bitbucket";
  uuid: string;
  workspaceUuid: string;
  createdAt?: number | undefined;
  deployHooks: Array<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLinkProjectsResponse200DeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type UpdateMicrofrontendsLink4 = {
  projectId: string;
  projectName: string;
  projectNameWithNamespace: string;
  projectNamespace: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes. This is the id of the top level group that a namespace belongs to. Gitlab supports group nesting (up to 20 levels).
   */
  projectOwnerId?: number | undefined;
  projectUrl: string;
  type: "gitlab";
  createdAt?: number | undefined;
  deployHooks: Array<UpdateMicrofrontendsLinkProjectsResponse200DeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLinkProjectsResponseDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type UpdateMicrofrontendsLink3 = {
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  repo?: string | undefined;
  repoId?: number | undefined;
  type: "github-custom-host";
  host: string;
  createdAt?: number | undefined;
  deployHooks: Array<UpdateMicrofrontendsLinkProjectsResponseDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLinkProjectsDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type UpdateMicrofrontendsLink2 = {
  type: "github-limited";
  repo?: string | undefined;
  repoId?: number | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  deployHooks: Array<UpdateMicrofrontendsLinkProjectsDeployHooks>;
  gitCredentialId: string;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLinkDeployHooks = {
  createdAt?: number | undefined;
  id: string;
  name: string;
  ref: string;
  url: string;
};

export type UpdateMicrofrontendsLink1 = {
  org: string;
  /**
   * A new field, should be included in all new project links, is being added just in time when a deployment is created. This is needed for Protected Git scopes.
   */
  repoOwnerId?: number | undefined;
  repo?: string | undefined;
  repoId?: number | undefined;
  type: "github";
  createdAt?: number | undefined;
  deployHooks: Array<UpdateMicrofrontendsLinkDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type UpdateMicrofrontendsLink =
  | UpdateMicrofrontendsLink1
  | UpdateMicrofrontendsLink2
  | UpdateMicrofrontendsLink3
  | UpdateMicrofrontendsLink4
  | UpdateMicrofrontendsLink5
  | UpdateMicrofrontendsLink6;

export type UpdateMicrofrontendsMicrofrontends3 = {
  updatedAt: number;
  groupIds: Array<any>;
  enabled: false;
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UpdateMicrofrontendsMicrofrontends2 = {
  isDefaultApp?: false | undefined;
  /**
   * Whether observability data should be routed to this microfrontend project or a root project.
   */
  routeObservabilityToThisProject?: boolean | undefined;
  /**
   * Whether to add microfrontends routing to aliases. This means domains in this project will route as a microfrontend.
   */
  doNotRouteWithMicrofrontendsRouting?: boolean | undefined;
  /**
   * Timestamp when the microfrontends settings were last updated.
   */
  updatedAt: number;
  /**
   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
   */
  groupIds: Array<string>;
  /**
   * Whether microfrontends are enabled for this project.
   */
  enabled: true;
  /**
   * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
   */
  defaultRoute?: string | undefined;
  /**
   * Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
   */
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UpdateMicrofrontendsMicrofrontends1 = {
  isDefaultApp: true;
  /**
   * Timestamp when the microfrontends settings were last updated.
   */
  updatedAt: number;
  /**
   * The group IDs of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
   */
  groupIds: Array<string>;
  /**
   * Whether microfrontends are enabled for this project.
   */
  enabled: true;
  /**
   * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI. Includes the leading slash, e.g. `/docs`
   */
  defaultRoute?: string | undefined;
  /**
   * Whether the project was part of the legacy limits for hobby and pro-trial before billing was added. This field is only set when the team is upgraded to a paid plan and we are backfilling the subscription status. We cap the subscription to 2 projects and set this field for the 3rd project. When this field is set, the project is not charged for and we do not call any billing APIs for this project.
   */
  freeProjectForLegacyLimits?: boolean | undefined;
};

export type UpdateMicrofrontendsMicrofrontends =
  | UpdateMicrofrontendsMicrofrontends1
  | UpdateMicrofrontendsMicrofrontends2
  | UpdateMicrofrontendsMicrofrontends3;

export const UpdateMicrofrontendsNodeVersion = {
  TenDotX: "10.x",
  TwelveDotX: "12.x",
  FourteenDotX: "14.x",
  SixteenDotX: "16.x",
  EighteenDotX: "18.x",
  TwentyDotX: "20.x",
  TwentyTwoDotX: "22.x",
  TwentyFourDotX: "24.x",
  EightDot10DotX: "8.10.x",
} as const;
export type UpdateMicrofrontendsNodeVersion = ClosedEnum<
  typeof UpdateMicrofrontendsNodeVersion
>;

export type UpdateMicrofrontendsPaths = {
  value: string;
};

export type UpdateMicrofrontendsOptionsAllowlist = {
  paths: Array<UpdateMicrofrontendsPaths>;
};

export type UpdateMicrofrontendsPasswordProtection = {};

export const UpdateMicrofrontendsDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type UpdateMicrofrontendsDeploymentType = ClosedEnum<
  typeof UpdateMicrofrontendsDeploymentType
>;

export type UpdateMicrofrontendsPassport = {
  deploymentType: UpdateMicrofrontendsDeploymentType;
  connectorId: string;
};

export type UpdateMicrofrontendsSandboxUrls = {
  inheritDeploymentProtection?: boolean | undefined;
};

export type UpdateMicrofrontendsProtectionConfig = {
  sandboxUrls?: UpdateMicrofrontendsSandboxUrls | undefined;
};

export const UpdateMicrofrontendsFunctionDefaultMemoryType = {
  Performance: "performance",
  PerformanceXl: "performance_xl",
  Standard: "standard",
  StandardLegacy: "standard_legacy",
} as const;
export type UpdateMicrofrontendsFunctionDefaultMemoryType = ClosedEnum<
  typeof UpdateMicrofrontendsFunctionDefaultMemoryType
>;

export const UpdateMicrofrontendsBuildMachineType = {
  Enhanced: "enhanced",
  Standard: "standard",
  Turbo: "turbo",
} as const;
export type UpdateMicrofrontendsBuildMachineType = ClosedEnum<
  typeof UpdateMicrofrontendsBuildMachineType
>;

export const UpdateMicrofrontendsBuildMachineSelection = {
  Elastic: "elastic",
  Fixed: "fixed",
} as const;
export type UpdateMicrofrontendsBuildMachineSelection = ClosedEnum<
  typeof UpdateMicrofrontendsBuildMachineSelection
>;

export const UpdateMicrofrontendsConfiguration = {
  SkipNamespaceQueue: "SKIP_NAMESPACE_QUEUE",
  WaitForNamespaceQueue: "WAIT_FOR_NAMESPACE_QUEUE",
} as const;
export type UpdateMicrofrontendsConfiguration = ClosedEnum<
  typeof UpdateMicrofrontendsConfiguration
>;

export type UpdateMicrofrontendsBuildQueue = {
  configuration?: UpdateMicrofrontendsConfiguration | undefined;
};

export type UpdateMicrofrontendsResourceConfig = {
  elasticConcurrencyEnabled?: boolean | undefined;
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | UpdateMicrofrontendsFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  buildMachineType?: UpdateMicrofrontendsBuildMachineType | undefined;
  buildMachineSelection?: UpdateMicrofrontendsBuildMachineSelection | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: UpdateMicrofrontendsBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

/**
 * Description of why a project was rolled back, and by whom. Note that lastAliasRequest contains the from/to details of the rollback.
 */
export type UpdateMicrofrontendsRollbackDescription = {
  /**
   * The user who rolled back the project.
   */
  userId: string;
  /**
   * The username of the user who rolled back the project.
   */
  username: string;
  /**
   * User-supplied explanation of why they rolled back the project. Limited to 250 characters.
   */
  description: string;
  /**
   * Timestamp of when the rollback was requested.
   */
  createdAt: number;
};

/**
 * An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100.
 */
export type UpdateMicrofrontendsStages = {
  /**
   * The percentage of traffic to serve to the canary deployment (0-100)
   */
  targetPercentage: number;
  /**
   * Whether or not this stage requires manual approval to proceed
   */
  requireApproval?: boolean | undefined;
  /**
   * Duration in minutes for automatic advancement to the next stage
   */
  duration?: number | undefined;
  /**
   * Whether to linearly shift traffic over the duration of this stage
   */
  linearShift?: boolean | undefined;
};

/**
 * Project-level rolling release configuration that defines how deployments should be gradually rolled out
 */
export type UpdateMicrofrontendsRollingRelease = {
  /**
   * The environment that the release targets, currently only supports production. Adding in case we want to configure with alias groups or custom environments.
   */
  target: string;
  /**
   * An array of all the stages required during a deployment release. Each stage defines a target percentage and advancement rules. The final stage must always have targetPercentage: 100.
   */
  stages?: Array<UpdateMicrofrontendsStages> | null | undefined;
  /**
   * Whether the request served by a canary deployment should return a header indicating a canary was served. Defaults to `false` when omitted.
   */
  canaryResponseHeader?: boolean | undefined;
};

export const UpdateMicrofrontendsProjectsFunctionDefaultMemoryType = {
  Performance: "performance",
  PerformanceXl: "performance_xl",
  Standard: "standard",
  StandardLegacy: "standard_legacy",
} as const;
export type UpdateMicrofrontendsProjectsFunctionDefaultMemoryType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsFunctionDefaultMemoryType
>;

export const UpdateMicrofrontendsProjectsBuildMachineType = {
  Enhanced: "enhanced",
  Standard: "standard",
  Turbo: "turbo",
} as const;
export type UpdateMicrofrontendsProjectsBuildMachineType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsBuildMachineType
>;

export const UpdateMicrofrontendsProjectsBuildMachineSelection = {
  Elastic: "elastic",
  Fixed: "fixed",
} as const;
export type UpdateMicrofrontendsProjectsBuildMachineSelection = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsBuildMachineSelection
>;

export const UpdateMicrofrontendsProjectsConfiguration = {
  SkipNamespaceQueue: "SKIP_NAMESPACE_QUEUE",
  WaitForNamespaceQueue: "WAIT_FOR_NAMESPACE_QUEUE",
} as const;
export type UpdateMicrofrontendsProjectsConfiguration = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsConfiguration
>;

export type UpdateMicrofrontendsProjectsBuildQueue = {
  configuration?: UpdateMicrofrontendsProjectsConfiguration | undefined;
};

export type UpdateMicrofrontendsDefaultResourceConfig = {
  elasticConcurrencyEnabled?: boolean | undefined;
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | UpdateMicrofrontendsProjectsFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  buildMachineType?: UpdateMicrofrontendsProjectsBuildMachineType | undefined;
  buildMachineSelection?:
    | UpdateMicrofrontendsProjectsBuildMachineSelection
    | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: UpdateMicrofrontendsProjectsBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

export type UpdateMicrofrontendsStaticIps = {
  builds: boolean;
  enabled: boolean;
  regions: Array<string>;
};

export const UpdateMicrofrontendsProjectsDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type UpdateMicrofrontendsProjectsDeploymentType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsDeploymentType
>;

export const UpdateMicrofrontendsCve55182MigrationAppliedFrom = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
} as const;
export type UpdateMicrofrontendsCve55182MigrationAppliedFrom = ClosedEnum<
  typeof UpdateMicrofrontendsCve55182MigrationAppliedFrom
>;

export const UpdateMicrofrontendsApril2026SecurityIncidentMigrationAppliedFrom =
  {
    All: "all",
    AllExceptCustomDomains: "all_except_custom_domains",
    Preview: "preview",
    ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
  } as const;
export type UpdateMicrofrontendsApril2026SecurityIncidentMigrationAppliedFrom =
  ClosedEnum<
    typeof UpdateMicrofrontendsApril2026SecurityIncidentMigrationAppliedFrom
  >;

export type UpdateMicrofrontendsSsoProtection = {
  deploymentType: UpdateMicrofrontendsProjectsDeploymentType;
  cve55182MigrationAppliedFrom?:
    | UpdateMicrofrontendsCve55182MigrationAppliedFrom
    | null
    | undefined;
  april2026SecurityIncidentMigrationAppliedFrom?:
    | UpdateMicrofrontendsApril2026SecurityIncidentMigrationAppliedFrom
    | null
    | undefined;
};

export type UpdateMicrofrontendsProjectsAliasAssigned = number | boolean;

export type UpdateMicrofrontendsProjectsBuilds = {
  use: string;
  src?: string | undefined;
  dest?: string | undefined;
};

export type UpdateMicrofrontendsProjectsCreator = {
  email: string;
  githubLogin?: string | undefined;
  gitlabLogin?: string | undefined;
  uid: string;
  username: string;
};

export type UpdateMicrofrontendsTargets = {
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  builds?: Array<UpdateMicrofrontendsProjectsBuilds> | undefined;
  createdAt: number;
  createdIn: string;
  creator: UpdateMicrofrontendsProjectsCreator | null;
  deploymentHostname: string;
  name: string;
  forced?: boolean | undefined;
  id: string;
  meta?: { [k: string]: string } | undefined;
  plan: string;
  private: boolean;
  readyState: string;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: string;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

export type UpdateMicrofrontendsPermissions = {
  oauth2Connection?: Array<ACLAction> | undefined;
  user?: Array<ACLAction> | undefined;
  userConnection?: Array<ACLAction> | undefined;
  userMfaConfiguration?: Array<ACLAction> | undefined;
  userPreference?: Array<ACLAction> | undefined;
  userSudo?: Array<ACLAction> | undefined;
  webAuthn?: Array<ACLAction> | undefined;
  accessGroup?: Array<ACLAction> | undefined;
  agent?: Array<ACLAction> | undefined;
  aiGatewayRules?: Array<ACLAction> | undefined;
  aiGatewayUsage?: Array<ACLAction> | undefined;
  alerts?: Array<ACLAction> | undefined;
  alertRules?: Array<ACLAction> | undefined;
  aliasGlobal?: Array<ACLAction> | undefined;
  analyticsSampling?: Array<ACLAction> | undefined;
  analyticsUsage?: Array<ACLAction> | undefined;
  apiKey?: Array<ACLAction> | undefined;
  apiKeyAiGateway?: Array<ACLAction> | undefined;
  apiKeyOwnedBySelf?: Array<ACLAction> | undefined;
  oauth2Application?: Array<ACLAction> | undefined;
  vercelAppInstallation?: Array<ACLAction> | undefined;
  vercelAppInstallationRequest?: Array<ACLAction> | undefined;
  auditLog?: Array<ACLAction> | undefined;
  billingAddress?: Array<ACLAction> | undefined;
  billingInformation?: Array<ACLAction> | undefined;
  billingInvoice?: Array<ACLAction> | undefined;
  billingInvoiceEmailRecipient?: Array<ACLAction> | undefined;
  billingInvoiceLanguage?: Array<ACLAction> | undefined;
  billingPlan?: Array<ACLAction> | undefined;
  billingPurchaseOrder?: Array<ACLAction> | undefined;
  billingRefund?: Array<ACLAction> | undefined;
  billingTaxId?: Array<ACLAction> | undefined;
  blob?: Array<ACLAction> | undefined;
  blobStoreTokenSet?: Array<ACLAction> | undefined;
  budget?: Array<ACLAction> | undefined;
  cacheArtifact?: Array<ACLAction> | undefined;
  cacheArtifactUsageEvent?: Array<ACLAction> | undefined;
  codeChecks?: Array<ACLAction> | undefined;
  ciInvocations?: Array<ACLAction> | undefined;
  ciLogs?: Array<ACLAction> | undefined;
  concurrentBuilds?: Array<ACLAction> | undefined;
  connect?: Array<ACLAction> | undefined;
  connectConfiguration?: Array<ACLAction> | undefined;
  connexClient?: Array<ACLAction> | undefined;
  connexClientProject?: Array<ACLAction> | undefined;
  connexToken?: Array<ACLAction> | undefined;
  buildMachineDefault?: Array<ACLAction> | undefined;
  dataCacheBillingSettings?: Array<ACLAction> | undefined;
  defaultDeploymentProtection?: Array<ACLAction> | undefined;
  deploymentPolicy?: Array<ACLAction> | undefined;
  domain?: Array<ACLAction> | undefined;
  domainAcceptDelegation?: Array<ACLAction> | undefined;
  domainAuthCodes?: Array<ACLAction> | undefined;
  domainCertificate?: Array<ACLAction> | undefined;
  domainCheckConfig?: Array<ACLAction> | undefined;
  domainMove?: Array<ACLAction> | undefined;
  domainPurchase?: Array<ACLAction> | undefined;
  domainRecord?: Array<ACLAction> | undefined;
  domainTransferIn?: Array<ACLAction> | undefined;
  drain?: Array<ACLAction> | undefined;
  edgeConfig?: Array<ACLAction> | undefined;
  edgeConfigItem?: Array<ACLAction> | undefined;
  edgeConfigSchema?: Array<ACLAction> | undefined;
  edgeConfigToken?: Array<ACLAction> | undefined;
  endpointVerification?: Array<ACLAction> | undefined;
  event?: Array<ACLAction> | undefined;
  fileUpload?: Array<ACLAction> | undefined;
  flagsExplorerSubscription?: Array<ACLAction> | undefined;
  gitRepository?: Array<ACLAction> | undefined;
  imageOptimizationNewPrice?: Array<ACLAction> | undefined;
  integration?: Array<ACLAction> | undefined;
  integrationAccount?: Array<ACLAction> | undefined;
  integrationConfiguration?: Array<ACLAction> | undefined;
  integrationConfigurationProjects?: Array<ACLAction> | undefined;
  integrationConfigurationRole?: Array<ACLAction> | undefined;
  integrationConfigurationTransfer?: Array<ACLAction> | undefined;
  integrationDeploymentAction?: Array<ACLAction> | undefined;
  integrationEvent?: Array<ACLAction> | undefined;
  integrationLog?: Array<ACLAction> | undefined;
  integrationResource?: Array<ACLAction> | undefined;
  integrationResourceData?: Array<ACLAction> | undefined;
  integrationResourceReplCommand?: Array<ACLAction> | undefined;
  integrationResourceSecrets?: Array<ACLAction> | undefined;
  integrationSSOSession?: Array<ACLAction> | undefined;
  integrationStrict?: Array<ACLAction> | undefined;
  integrationStoreTokenSet?: Array<ACLAction> | undefined;
  integrationVercelConfigurationOverride?: Array<ACLAction> | undefined;
  integrationPullRequest?: Array<ACLAction> | undefined;
  ipBlocking?: Array<ACLAction> | undefined;
  jobGlobal?: Array<ACLAction> | undefined;
  kmsIssuer?: Array<ACLAction> | undefined;
  kmsProjectGrant?: Array<ACLAction> | undefined;
  logDrain?: Array<ACLAction> | undefined;
  marketplaceBillingData?: Array<ACLAction> | undefined;
  marketplaceExperimentationEdgeConfigData?: Array<ACLAction> | undefined;
  marketplaceExperimentationItem?: Array<ACLAction> | undefined;
  marketplaceInstallationMember?: Array<ACLAction> | undefined;
  marketplaceInvoice?: Array<ACLAction> | undefined;
  marketplaceSettings?: Array<ACLAction> | undefined;
  monitoring?: Array<ACLAction> | undefined;
  monitoringAlert?: Array<ACLAction> | undefined;
  monitoringChart?: Array<ACLAction> | undefined;
  monitoringQuery?: Array<ACLAction> | undefined;
  monitoringSettings?: Array<ACLAction> | undefined;
  notificationCustomerBudget?: Array<ACLAction> | undefined;
  notificationDeploymentFailed?: Array<ACLAction> | undefined;
  notificationDomainConfiguration?: Array<ACLAction> | undefined;
  notificationDomainExpire?: Array<ACLAction> | undefined;
  notificationDomainMoved?: Array<ACLAction> | undefined;
  notificationDomainPurchase?: Array<ACLAction> | undefined;
  notificationDomainRenewal?: Array<ACLAction> | undefined;
  notificationDomainTransfer?: Array<ACLAction> | undefined;
  notificationDomainUnverified?: Array<ACLAction> | undefined;
  notificationMonitoringAlert?: Array<ACLAction> | undefined;
  notificationPaymentFailed?: Array<ACLAction> | undefined;
  notificationPreferences?: Array<ACLAction> | undefined;
  notificationStatementOfReasons?: Array<ACLAction> | undefined;
  notificationUsageAlert?: Array<ACLAction> | undefined;
  oidcFederationPolicy?: Array<ACLAction> | undefined;
  observabilityConfiguration?: Array<ACLAction> | undefined;
  observabilityFunnel?: Array<ACLAction> | undefined;
  observabilityNotebook?: Array<ACLAction> | undefined;
  openTelemetryEndpoint?: Array<ACLAction> | undefined;
  ownEvent?: Array<ACLAction> | undefined;
  organization?: Array<ACLAction> | undefined;
  organizationDomain?: Array<ACLAction> | undefined;
  organizationTeam?: Array<ACLAction> | undefined;
  passwordProtectionInvoiceItem?: Array<ACLAction> | undefined;
  paymentMethod?: Array<ACLAction> | undefined;
  permissions?: Array<ACLAction> | undefined;
  postgres?: Array<ACLAction> | undefined;
  postgresStoreTokenSet?: Array<ACLAction> | undefined;
  previewDeploymentSuffix?: Array<ACLAction> | undefined;
  privateCloudAccount?: Array<ACLAction> | undefined;
  projectTransferIn?: Array<ACLAction> | undefined;
  proTrialOnboarding?: Array<ACLAction> | undefined;
  rateLimit?: Array<ACLAction> | undefined;
  redis?: Array<ACLAction> | undefined;
  redisStoreTokenSet?: Array<ACLAction> | undefined;
  remoteCaching?: Array<ACLAction> | undefined;
  repository?: Array<ACLAction> | undefined;
  samlConfig?: Array<ACLAction> | undefined;
  secret?: Array<ACLAction> | undefined;
  sensitiveEnvironmentVariablePolicy?: Array<ACLAction> | undefined;
  sharedEnvVars?: Array<ACLAction> | undefined;
  sharedEnvVarsProduction?: Array<ACLAction> | undefined;
  space?: Array<ACLAction> | undefined;
  spaceRun?: Array<ACLAction> | undefined;
  storeIsLocked?: Array<ACLAction> | undefined;
  storeTokenSetSensitive?: Array<ACLAction> | undefined;
  storeTransfer?: Array<ACLAction> | undefined;
  supportCase?: Array<ACLAction> | undefined;
  supportCaseComment?: Array<ACLAction> | undefined;
  team?: Array<ACLAction> | undefined;
  teamAccessRequest?: Array<ACLAction> | undefined;
  teamFellowMembership?: Array<ACLAction> | undefined;
  teamGitExclusivity?: Array<ACLAction> | undefined;
  teamInvite?: Array<ACLAction> | undefined;
  teamInviteCode?: Array<ACLAction> | undefined;
  teamInviteLink?: Array<ACLAction> | undefined;
  teamJoin?: Array<ACLAction> | undefined;
  teamMemberMfaStatus?: Array<ACLAction> | undefined;
  teamMicrofrontends?: Array<ACLAction> | undefined;
  teamOwnMembership?: Array<ACLAction> | undefined;
  teamOwnMembershipDisconnectSAML?: Array<ACLAction> | undefined;
  teamSudo?: Array<ACLAction> | undefined;
  teamTokenInvalidation?: Array<ACLAction> | undefined;
  token?: Array<ACLAction> | undefined;
  toolbarComment?: Array<ACLAction> | undefined;
  usage?: Array<ACLAction> | undefined;
  usageCycle?: Array<ACLAction> | undefined;
  vcrRepository?: Array<ACLAction> | undefined;
  vercelRun?: Array<ACLAction> | undefined;
  vpcPeeringConnection?: Array<ACLAction> | undefined;
  webAnalyticsPlan?: Array<ACLAction> | undefined;
  webhook?: Array<ACLAction> | undefined;
  webhookEvent?: Array<ACLAction> | undefined;
  aliasProject?: Array<ACLAction> | undefined;
  aliasProtectionBypass?: Array<ACLAction> | undefined;
  bulkRedirects?: Array<ACLAction> | undefined;
  buildMachine?: Array<ACLAction> | undefined;
  connectConfigurationLink?: Array<ACLAction> | undefined;
  dataCacheNamespace?: Array<ACLAction> | undefined;
  deployment?: Array<ACLAction> | undefined;
  deploymentBuildLogs?: Array<ACLAction> | undefined;
  deploymentCheck?: Array<ACLAction> | undefined;
  deploymentCheckPreview?: Array<ACLAction> | undefined;
  deploymentCheckReRunFromProductionBranch?: Array<ACLAction> | undefined;
  deploymentProductionGit?: Array<ACLAction> | undefined;
  deploymentV0?: Array<ACLAction> | undefined;
  deploymentPreview?: Array<ACLAction> | undefined;
  deploymentPrivate?: Array<ACLAction> | undefined;
  deploymentPromote?: Array<ACLAction> | undefined;
  deploymentRollback?: Array<ACLAction> | undefined;
  edgeCacheNamespace?: Array<ACLAction> | undefined;
  environments?: Array<ACLAction> | undefined;
  job?: Array<ACLAction> | undefined;
  logs?: Array<ACLAction> | undefined;
  logsPreset?: Array<ACLAction> | undefined;
  observabilityData?: Array<ACLAction> | undefined;
  onDemandBuild?: Array<ACLAction> | undefined;
  onDemandConcurrency?: Array<ACLAction> | undefined;
  optionsAllowlist?: Array<ACLAction> | undefined;
  passwordProtection?: Array<ACLAction> | undefined;
  privateLinkEndpoint?: Array<ACLAction> | undefined;
  productionAliasProtectionBypass?: Array<ACLAction> | undefined;
  project?: Array<ACLAction> | undefined;
  projectAccessGroup?: Array<ACLAction> | undefined;
  projectAnalyticsSampling?: Array<ACLAction> | undefined;
  projectAnalyticsUsage?: Array<ACLAction> | undefined;
  projectCheck?: Array<ACLAction> | undefined;
  projectCheckRun?: Array<ACLAction> | undefined;
  projectDeploymentExpiration?: Array<ACLAction> | undefined;
  projectDeploymentHook?: Array<ACLAction> | undefined;
  projectDeploymentProtectionStrict?: Array<ACLAction> | undefined;
  projectDomain?: Array<ACLAction> | undefined;
  projectDomainCheckConfig?: Array<ACLAction> | undefined;
  projectDomainMove?: Array<ACLAction> | undefined;
  projectEvent?: Array<ACLAction> | undefined;
  projectEnvVars?: Array<ACLAction> | undefined;
  projectEnvVarsProduction?: Array<ACLAction> | undefined;
  projectEnvVarsUnownedByIntegration?: Array<ACLAction> | undefined;
  projectFlags?: Array<ACLAction> | undefined;
  projectFlagsProduction?: Array<ACLAction> | undefined;
  projectFlagsSDKKey?: Array<ACLAction> | undefined;
  projectFromV0?: Array<ACLAction> | undefined;
  projectId?: Array<ACLAction> | undefined;
  projectIntegrationConfiguration?: Array<ACLAction> | undefined;
  projectLink?: Array<ACLAction> | undefined;
  projectMember?: Array<ACLAction> | undefined;
  projectMonitoring?: Array<ACLAction> | undefined;
  projectOIDCToken?: Array<ACLAction> | undefined;
  projectPermissions?: Array<ACLAction> | undefined;
  projectProductionBranch?: Array<ACLAction> | undefined;
  projectProtectionBypass?: Array<ACLAction> | undefined;
  projectRollingRelease?: Array<ACLAction> | undefined;
  projectRoutes?: Array<ACLAction> | undefined;
  projectSupportCase?: Array<ACLAction> | undefined;
  projectSupportCaseComment?: Array<ACLAction> | undefined;
  projectTier?: Array<ACLAction> | undefined;
  projectTransfer?: Array<ACLAction> | undefined;
  projectTransferOut?: Array<ACLAction> | undefined;
  projectUsage?: Array<ACLAction> | undefined;
  pageIntegrity?: Array<ACLAction> | undefined;
  seawallConfig?: Array<ACLAction> | undefined;
  securityPlusConfiguration?: Array<ACLAction> | undefined;
  shareableLinkStrict?: Array<ACLAction> | undefined;
  sharedEnvVarConnection?: Array<ACLAction> | undefined;
  skewProtection?: Array<ACLAction> | undefined;
  analytics?: Array<ACLAction> | undefined;
  trustedIps?: Array<ACLAction> | undefined;
  trustedSources?: Array<ACLAction> | undefined;
  v0Chat?: Array<ACLAction> | undefined;
  webAnalytics?: Array<ACLAction> | undefined;
};

export type UpdateMicrofrontendsLastRollbackTarget = {};

export const UpdateMicrofrontendsJobStatus = {
  Failed: "failed",
  InProgress: "in-progress",
  Pending: "pending",
  Skipped: "skipped",
  Succeeded: "succeeded",
} as const;
export type UpdateMicrofrontendsJobStatus = ClosedEnum<
  typeof UpdateMicrofrontendsJobStatus
>;

export const UpdateMicrofrontendsProjectsResponseType = {
  Promote: "promote",
  Rollback: "rollback",
} as const;
export type UpdateMicrofrontendsProjectsResponseType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseType
>;

export type UpdateMicrofrontendsLastAliasRequest = {
  fromDeploymentId: string | null;
  toDeploymentId: string;
  /**
   * If rolling back from a rolling release, fromDeploymentId captures the "base" of that rolling release, and fromRollingReleaseId captures the "target" of that rolling release.
   */
  fromRollingReleaseId?: string | undefined;
  jobStatus: UpdateMicrofrontendsJobStatus;
  requestedAt: number;
  type: UpdateMicrofrontendsProjectsResponseType;
};

export type UpdateMicrofrontendsProtectionBypass2 = {
  createdAt: number;
  createdBy: string;
  scope: "automation-bypass";
  /**
   * When there was only one bypass, it was automatically set as an env var on deployments. With multiple bypasses, there is always one bypass that is selected as the default, and gets set as an env var on deployments. As this is a new field, undefined means that the bypass is the env var. If there are any automation bypasses, exactly one must be the env var.
   */
  isEnvVar?: boolean | undefined;
  /**
   * Optional note about the bypass to be displayed in the UI
   */
  note?: string | undefined;
};

export type UpdateMicrofrontendsProtectionBypass1 = {
  createdAt: number;
  createdBy: string;
  scope: "integration-automation-bypass";
  integrationId: string;
  configurationId: string;
};

export type UpdateMicrofrontendsProtectionBypass =
  | UpdateMicrofrontendsProtectionBypass1
  | UpdateMicrofrontendsProtectionBypass2;

export const UpdateMicrofrontendsTrustedIpsProjectsDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
  Production: "production",
} as const;
export type UpdateMicrofrontendsTrustedIpsProjectsDeploymentType = ClosedEnum<
  typeof UpdateMicrofrontendsTrustedIpsProjectsDeploymentType
>;

export type UpdateMicrofrontendsTrustedIps2 = {
  deploymentType: UpdateMicrofrontendsTrustedIpsProjectsDeploymentType;
};

export const UpdateMicrofrontendsTrustedIpsDeploymentType = {
  All: "all",
  AllExceptCustomDomains: "all_except_custom_domains",
  Preview: "preview",
  ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews",
  Production: "production",
} as const;
export type UpdateMicrofrontendsTrustedIpsDeploymentType = ClosedEnum<
  typeof UpdateMicrofrontendsTrustedIpsDeploymentType
>;

export type UpdateMicrofrontendsTrustedIpsAddresses = {
  value: string;
  note?: string | undefined;
};

export const UpdateMicrofrontendsTrustedIpsProtectionMode = {
  Additional: "additional",
  Exclusive: "exclusive",
} as const;
export type UpdateMicrofrontendsTrustedIpsProtectionMode = ClosedEnum<
  typeof UpdateMicrofrontendsTrustedIpsProtectionMode
>;

export type UpdateMicrofrontendsTrustedIps1 = {
  deploymentType: UpdateMicrofrontendsTrustedIpsDeploymentType;
  addresses: Array<UpdateMicrofrontendsTrustedIpsAddresses>;
  protectionMode: UpdateMicrofrontendsTrustedIpsProtectionMode;
};

export type UpdateMicrofrontendsTrustedIps =
  | UpdateMicrofrontendsTrustedIps1
  | UpdateMicrofrontendsTrustedIps2;

export const UpdateMicrofrontendsFromProjectsPreset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsFromProjectsPreset = ClosedEnum<
  typeof UpdateMicrofrontendsFromProjectsPreset
>;

/**
 * The source envs on the trusted project that are allowed to access `to`.
 */
export type UpdateMicrofrontendsFrom2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: UpdateMicrofrontendsFromProjectsPreset;
};

export const UpdateMicrofrontendsFromPreset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsFromPreset = ClosedEnum<
  typeof UpdateMicrofrontendsFromPreset
>;

/**
 * The source envs on the trusted project that are allowed to access `to`.
 */
export type UpdateMicrofrontendsFrom1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: UpdateMicrofrontendsFromPreset | undefined;
};

export type UpdateMicrofrontendsFrom =
  | UpdateMicrofrontendsFrom1
  | UpdateMicrofrontendsFrom2;

export const UpdateMicrofrontendsToProjectsResponse200Preset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsToProjectsResponse200Preset = ClosedEnum<
  typeof UpdateMicrofrontendsToProjectsResponse200Preset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type UpdateMicrofrontendsToProjects2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: UpdateMicrofrontendsToProjectsResponse200Preset;
};

export const UpdateMicrofrontendsToProjectsResponsePreset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsToProjectsResponsePreset = ClosedEnum<
  typeof UpdateMicrofrontendsToProjectsResponsePreset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type UpdateMicrofrontendsToProjects1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: UpdateMicrofrontendsToProjectsResponsePreset | undefined;
};

export type UpdateMicrofrontendsProjectsTo =
  | UpdateMicrofrontendsToProjects1
  | UpdateMicrofrontendsToProjects2;

/**
 * Optional overrides for the default same-env-by-slug matching. Provide explicit rules to allow cross-env access or presets.
 */
export type UpdateMicrofrontendsCustomAllow = {
  from: UpdateMicrofrontendsFrom1 | UpdateMicrofrontendsFrom2;
  to: UpdateMicrofrontendsToProjects1 | UpdateMicrofrontendsToProjects2;
};

export type UpdateMicrofrontendsProjects = {
  label?: string | undefined;
  /**
   * Optional overrides for the default same-env-by-slug matching. Provide explicit rules to allow cross-env access or presets.
   */
  customAllow?: Array<UpdateMicrofrontendsCustomAllow> | undefined;
};

export const UpdateMicrofrontendsToProjectsPreset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsToProjectsPreset = ClosedEnum<
  typeof UpdateMicrofrontendsToProjectsPreset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type UpdateMicrofrontendsTo2 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs?: Array<string> | undefined;
  preset: UpdateMicrofrontendsToProjectsPreset;
};

export const UpdateMicrofrontendsToPreset = {
  AllCustom: "all-custom",
} as const;
export type UpdateMicrofrontendsToPreset = ClosedEnum<
  typeof UpdateMicrofrontendsToPreset
>;

/**
 * The target envs on the current project that may be accessed.
 */
export type UpdateMicrofrontendsTo1 = {
  /**
   * System environment slugs (`production`, `preview`) and/or custom environment slugs defined on the referenced project.
   */
  slugs: Array<string>;
  preset?: UpdateMicrofrontendsToPreset | undefined;
};

export type UpdateMicrofrontendsTo =
  | UpdateMicrofrontendsTo1
  | UpdateMicrofrontendsTo2;

export type UpdateMicrofrontendsOidcProviders = {
  to: UpdateMicrofrontendsTo1 | UpdateMicrofrontendsTo2;
  label?: string | undefined;
  claims: { [k: string]: Array<string> };
};

export type UpdateMicrofrontendsTrustedSources = {
  projects?: { [k: string]: UpdateMicrofrontendsProjects } | undefined;
  oidcProviders?:
    | { [k: string]: Array<UpdateMicrofrontendsOidcProviders> }
    | undefined;
};

export type UpdateMicrofrontendsGitComments = {
  /**
   * Whether the Vercel bot should comment on PRs
   */
  onPullRequest: boolean;
  /**
   * Whether the Vercel bot should comment on commits
   */
  onCommit: boolean;
};

/**
 * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
 */
export const UpdateMicrofrontendsCreateDeployments = {
  Disabled: "disabled",
  Enabled: "enabled",
} as const;
/**
 * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
 */
export type UpdateMicrofrontendsCreateDeployments = ClosedEnum<
  typeof UpdateMicrofrontendsCreateDeployments
>;

/**
 * Configuration for consolidated git commit status reporting. When enabled, Vercel will post a single consolidated commit status instead of individual statuses for each deployment.
 */
export type UpdateMicrofrontendsConsolidatedGitCommitStatus = {
  /**
   * Whether consolidated commit status is enabled.
   */
  enabled: boolean;
  /**
   * Whether to propagate individual deployment failures to the consolidated status.
   */
  propagateFailures: boolean;
};

export type UpdateMicrofrontendsGitProviderOptions = {
  /**
   * Whether the Vercel bot should automatically create GitHub deployments https://docs.github.com/en/rest/deployments/deployments#about-deployments NOTE: repository-dispatch events should be used instead
   */
  createDeployments: UpdateMicrofrontendsCreateDeployments;
  /**
   * Whether the Vercel bot should not automatically create GitHub repository-dispatch events on deployment events. https://vercel.com/docs/git/vercel-for-github#repository-dispatch-events - `true`: disable repository-dispatch events for this project (explicit override of the team setting). - `false`: enable repository-dispatch events for this project (explicit override of the team setting). - absent: inherit from `team.disableRepositoryDispatchEvents`.
   */
  disableRepositoryDispatchEvents?: boolean | undefined;
  /**
   * Whether the project requires commits to be signed & verified before deployments will be created. - `true`: require verified commits for this project (explicit override of the team setting). - `false`: do not require verified commits (explicit override of the team setting). - absent: inherit from `team.requireVerifiedCommits`.
   */
  requireVerifiedCommits?: boolean | undefined;
  /**
   * Whether Vercel should post commit statuses for this project. When omitted, commit statuses remain enabled.
   */
  gitCommitStatus?: boolean | undefined;
  /**
   * Configuration for consolidated git commit status reporting. When enabled, Vercel will post a single consolidated commit status instead of individual statuses for each deployment.
   */
  consolidatedGitCommitStatus?:
    | UpdateMicrofrontendsConsolidatedGitCommitStatus
    | undefined;
};

export type UpdateMicrofrontendsWebAnalytics = {
  id: string;
  disabledAt?: number | undefined;
  canceledAt?: number | undefined;
  enabledAt?: number | undefined;
  hasData?: true | undefined;
};

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

export type UpdateMicrofrontendsVercelRuleset = {
  active: boolean;
  action?:
    | UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAction
    | undefined;
};

/** @internal */
export type UpdateMicrofrontendsRequestBody$Outbound = {
  microfrontendsGroupId?: string | undefined;
  enabled?: boolean | undefined;
  isDefaultApp?: boolean | undefined;
  defaultRoute?: string | undefined;
  routeObservabilityToThisProject?: boolean | undefined;
  doNotRouteWithMicrofrontendsRouting?: boolean | undefined;
};

/** @internal */
export const UpdateMicrofrontendsRequestBody$outboundSchema: z.ZodType<
  UpdateMicrofrontendsRequestBody$Outbound,
  z.ZodTypeDef,
  UpdateMicrofrontendsRequestBody
> = z.object({
  microfrontendsGroupId: z.string().optional(),
  enabled: z.boolean().optional(),
  isDefaultApp: z.boolean().optional(),
  defaultRoute: z.string().optional(),
  routeObservabilityToThisProject: z.boolean().optional(),
  doNotRouteWithMicrofrontendsRouting: z.boolean().optional(),
});

export function updateMicrofrontendsRequestBodyToJSON(
  updateMicrofrontendsRequestBody: UpdateMicrofrontendsRequestBody,
): string {
  return JSON.stringify(
    UpdateMicrofrontendsRequestBody$outboundSchema.parse(
      updateMicrofrontendsRequestBody,
    ),
  );
}

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

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

export function updateMicrofrontendsRequestToJSON(
  updateMicrofrontendsRequest: UpdateMicrofrontendsRequest,
): string {
  return JSON.stringify(
    UpdateMicrofrontendsRequest$outboundSchema.parse(
      updateMicrofrontendsRequest,
    ),
  );
}

/** @internal */
export const UpdateMicrofrontendsAnalytics$inboundSchema: z.ZodType<
  UpdateMicrofrontendsAnalytics,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  canceledAt: z.nullable(types.number()).optional(),
  disabledAt: types.number(),
  enabledAt: types.number(),
  paidAt: types.optional(types.number()),
  sampleRatePercent: z.nullable(types.number()).optional(),
  spendLimitInDollars: z.nullable(types.number()).optional(),
});

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

/** @internal */
export const UpdateMicrofrontendsSpeedInsights$inboundSchema: z.ZodType<
  UpdateMicrofrontendsSpeedInsights,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  enabledAt: types.optional(types.number()),
  disabledAt: types.optional(types.number()),
  canceledAt: types.optional(types.number()),
  hasData: types.optional(types.boolean()),
  paidAt: types.optional(types.number()),
});

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsAws$inboundSchema: z.ZodType<
  UpdateMicrofrontendsAws,
  z.ZodTypeDef,
  unknown
> = z.object({
  subnetIds: z.array(types.string()),
  securityGroupId: types.optional(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsConnectConfigurations$inboundSchema: z.ZodType<
  UpdateMicrofrontendsConnectConfigurations,
  z.ZodTypeDef,
  unknown
> = z.object({
  envId: smartUnion([types.string(), UpdateMicrofrontendsEnvId2$inboundSchema]),
  connectConfigurationId: types.string(),
  dc: types.optional(types.string()),
  passive: types.boolean(),
  buildsEnabled: types.boolean(),
  aws: types.optional(z.lazy(() => UpdateMicrofrontendsAws$inboundSchema)),
  createdAt: types.number(),
  updatedAt: types.number(),
});

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

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

/** @internal */
export const UpdateMicrofrontendsDefinitions$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDefinitions,
  z.ZodTypeDef,
  unknown
> = z.object({
  host: types.string(),
  path: types.string(),
  schedule: types.string(),
  source: types.optional(UpdateMicrofrontendsSource$inboundSchema),
  description: types.optional(types.string()),
  hostInferred: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsCrons$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCrons,
  z.ZodTypeDef,
  unknown
> = z.object({
  enabledAt: types.number(),
  disabledAt: types.nullable(types.number()),
  updatedAt: types.number(),
  deploymentId: types.nullable(types.string()),
  definitions: z.array(
    z.lazy(() => UpdateMicrofrontendsDefinitions$inboundSchema),
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsDataCache$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDataCache,
  z.ZodTypeDef,
  unknown
> = z.object({
  userDisabled: types.boolean(),
  storageSizeBytes: z.nullable(types.number()).optional(),
  unlimited: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsDeploymentExpiration$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDeploymentExpiration,
  z.ZodTypeDef,
  unknown
> = z.object({
  expirationDays: types.optional(types.number()),
  expirationDaysProduction: types.optional(types.number()),
  expirationDaysCanceled: types.optional(types.number()),
  expirationDaysErrored: types.optional(types.number()),
  deploymentsToKeep: types.optional(types.number()),
});

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

/** @internal */
export const UpdateMicrofrontendsExpiration2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsExpiration2,
  z.ZodTypeDef,
  unknown
> = z.object({
  lockedAt: types.number(),
  lockedBy: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsExpiration1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsExpiration1,
  z.ZodTypeDef,
  unknown
> = z.object({
  expiresAt: types.number(),
});

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

/** @internal */
export const UpdateMicrofrontendsExpiration$inboundSchema: z.ZodType<
  UpdateMicrofrontendsExpiration,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsExpiration2$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsExpiration1$inboundSchema),
]);

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

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsContentHint17$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint17,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("flags-connection-string"),
  projectId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint16$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint16,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("integration-store-secret"),
  storeId: types.string(),
  integrationId: types.string(),
  integrationProductId: types.string(),
  integrationConfigurationId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint15$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint15,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-no-ssl"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint14$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint14,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-database"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint13$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint13,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-password"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint12$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint12,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-host"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint11$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint11,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-user"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint10$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint10,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-prisma-url"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint9$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint9,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url-non-pooling"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint8$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint8,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("postgres-url"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint7$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint7,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-webhook-public-key"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint6$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint6,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-store-id"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint5$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint5,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("blob-read-write-token"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint4$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-read-only-token"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint3$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-token"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-rest-api-url"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("redis-url"),
  storeId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsContentHint$inboundSchema: z.ZodType<
  UpdateMicrofrontendsContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateMicrofrontendsContentHint1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint2$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint3$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint4$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint5$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint6$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint7$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint8$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint9$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint10$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint11$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint12$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint13$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint14$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint15$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint16$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsContentHint17$inboundSchema),
]);

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

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

/** @internal */
export const UpdateMicrofrontendsInternalContentHint$inboundSchema: z.ZodType<
  UpdateMicrofrontendsInternalContentHint,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONType$inboundSchema,
  encryptedValue: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsEnv$inboundSchema: z.ZodType<
  UpdateMicrofrontendsEnv,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(UpdateMicrofrontendsTarget1$inboundSchema),
      UpdateMicrofrontendsTarget2$inboundSchema,
    ]),
  ),
  type: UpdateMicrofrontendsType$inboundSchema,
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  value: types.string(),
  vsmValue: types.optional(types.string()),
  id: types.optional(types.string()),
  key: types.string(),
  configurationId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  gitBranch: types.optional(types.string()),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => UpdateMicrofrontendsContentHint1$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint2$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint3$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint4$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint5$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint6$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint7$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint8$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint9$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint10$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint11$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint12$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint13$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint14$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint15$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint16$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => UpdateMicrofrontendsInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsBranchMatcher$inboundSchema: z.ZodType<
  UpdateMicrofrontendsBranchMatcher,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: UpdateMicrofrontendsProjectsResponse200Type$inboundSchema,
  pattern: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsVerification$inboundSchema: z.ZodType<
  UpdateMicrofrontendsVerification,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.string(),
  domain: types.string(),
  value: types.string(),
  reason: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsDomains$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDomains,
  z.ZodTypeDef,
  unknown
> = z.object({
  name: types.string(),
  apexName: types.string(),
  projectId: types.string(),
  redirect: z.nullable(types.string()).optional(),
  redirectStatusCode: z.nullable(types.number()).optional(),
  gitBranch: z.nullable(types.string()).optional(),
  customEnvironmentId: z.nullable(types.string()).optional(),
  updatedAt: types.optional(types.number()),
  createdAt: types.optional(types.number()),
  verified: types.boolean(),
  verification: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsVerification$inboundSchema)),
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsCustomEnvironments$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCustomEnvironments,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  slug: types.string(),
  type: UpdateMicrofrontendsProjectsType$inboundSchema,
  description: types.optional(types.string()),
  branchMatcher: types.optional(
    z.lazy(() => UpdateMicrofrontendsBranchMatcher$inboundSchema),
  ),
  domains: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsDomains$inboundSchema)),
  ),
  currentDeploymentAliases: types.optional(z.array(types.string())),
  createdAt: types.number(),
  updatedAt: types.number(),
});

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsServices$inboundSchema: z.ZodType<
  UpdateMicrofrontendsServices,
  z.ZodTypeDef,
  unknown
> = z.object({
  serviceName: types.string(),
  serviceType: types.optional(UpdateMicrofrontendsServiceType$inboundSchema),
  framework: types.optional(
    UpdateMicrofrontendsProjectsFramework$inboundSchema,
  ),
  runtime: types.optional(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsIpBuckets$inboundSchema: z.ZodType<
  UpdateMicrofrontendsIpBuckets,
  z.ZodTypeDef,
  unknown
> = z.object({
  bucket: types.string(),
  default: types.optional(types.boolean()),
  supportUntil: types.optional(types.number()),
});

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

/** @internal */
export const UpdateMicrofrontendsLint$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLint,
  z.ZodTypeDef,
  unknown
> = z.object({
  targets: z.array(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsTypecheck$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTypecheck,
  z.ZodTypeDef,
  unknown
> = z.object({
  targets: z.array(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsMfeConfigPresent$inboundSchema: z.ZodType<
  UpdateMicrofrontendsMfeConfigPresent,
  z.ZodTypeDef,
  unknown
> = z.object({
  targets: z.array(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsJobs$inboundSchema: z.ZodType<
  UpdateMicrofrontendsJobs,
  z.ZodTypeDef,
  unknown
> = z.object({
  lint: types.optional(z.lazy(() => UpdateMicrofrontendsLint$inboundSchema)),
  typecheck: types.optional(
    z.lazy(() => UpdateMicrofrontendsTypecheck$inboundSchema),
  ),
  "mfe-config-present": types.optional(
    z.lazy(() => UpdateMicrofrontendsMfeConfigPresent$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "mfe-config-present": "mfeConfigPresent",
  });
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsBuilds$inboundSchema: z.ZodType<
  UpdateMicrofrontendsBuilds,
  z.ZodTypeDef,
  unknown
> = z.object({
  use: types.string(),
  src: types.optional(types.string()),
  dest: types.optional(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsCreator$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator,
  z.ZodTypeDef,
  unknown
> = z.object({
  email: types.string(),
  githubLogin: types.optional(types.string()),
  gitlabLogin: types.optional(types.string()),
  uid: types.string(),
  username: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLatestDeployments$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLatestDeployments,
  z.ZodTypeDef,
  unknown
> = z.object({
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  builds: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UpdateMicrofrontendsCreator$inboundSchema),
  ),
  deploymentHostname: types.string(),
  name: types.string(),
  forced: types.optional(types.boolean()),
  id: types.string(),
  meta: types.optional(z.record(types.string())),
  plan: types.string(),
  private: types.boolean(),
  readyState: types.string(),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: types.string(),
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink6$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink6,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repo: types.string(),
  type: types.literal("vercel"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBodyDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink5$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink5,
  z.ZodTypeDef,
  unknown
> = z.object({
  name: types.string(),
  slug: types.string(),
  owner: types.string(),
  type: types.literal("bitbucket"),
  uuid: types.string(),
  workspaceUuid: types.string(),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkProjectsResponse200DeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsResponse200DeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink4$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink4,
  z.ZodTypeDef,
  unknown
> = z.object({
  projectId: types.string(),
  projectName: types.string(),
  projectNameWithNamespace: types.string(),
  projectNamespace: types.string(),
  projectOwnerId: types.optional(types.number()),
  projectUrl: types.string(),
  type: types.literal("gitlab"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      UpdateMicrofrontendsLinkProjectsResponse200DeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkProjectsResponseDeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsResponseDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink3$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink3,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  type: types.literal("github-custom-host"),
  host: types.string(),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      UpdateMicrofrontendsLinkProjectsResponseDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkProjectsDeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsDeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("github-limited"),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() => UpdateMicrofrontendsLinkProjectsDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLinkDeployHooks$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLinkDeployHooks,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.optional(types.number()),
  id: types.string(),
  name: types.string(),
  ref: types.string(),
  url: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLink1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink1,
  z.ZodTypeDef,
  unknown
> = z.object({
  org: types.string(),
  repoOwnerId: types.optional(types.number()),
  repo: types.optional(types.string()),
  repoId: types.optional(types.number()),
  type: types.literal("github"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() => UpdateMicrofrontendsLinkDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsLink$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateMicrofrontendsLink1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink2$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink3$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink4$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink5$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink6$inboundSchema),
]);

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

/** @internal */
export const UpdateMicrofrontendsMicrofrontends3$inboundSchema: z.ZodType<
  UpdateMicrofrontendsMicrofrontends3,
  z.ZodTypeDef,
  unknown
> = z.object({
  updatedAt: types.number(),
  groupIds: z.array(z.any()),
  enabled: types.literal(false),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsMicrofrontends2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsMicrofrontends2,
  z.ZodTypeDef,
  unknown
> = z.object({
  isDefaultApp: types.optional(types.literal(false)),
  routeObservabilityToThisProject: types.optional(types.boolean()),
  doNotRouteWithMicrofrontendsRouting: types.optional(types.boolean()),
  updatedAt: types.number(),
  groupIds: z.array(types.string()),
  enabled: types.literal(true),
  defaultRoute: types.optional(types.string()),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsMicrofrontends1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsMicrofrontends1,
  z.ZodTypeDef,
  unknown
> = z.object({
  isDefaultApp: types.literal(true),
  updatedAt: types.number(),
  groupIds: z.array(types.string()),
  enabled: types.literal(true),
  defaultRoute: types.optional(types.string()),
  freeProjectForLegacyLimits: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsMicrofrontends$inboundSchema: z.ZodType<
  UpdateMicrofrontendsMicrofrontends,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsMicrofrontends1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsMicrofrontends2$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsMicrofrontends3$inboundSchema),
]);

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

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

/** @internal */
export const UpdateMicrofrontendsPaths$inboundSchema: z.ZodType<
  UpdateMicrofrontendsPaths,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsOptionsAllowlist$inboundSchema: z.ZodType<
  UpdateMicrofrontendsOptionsAllowlist,
  z.ZodTypeDef,
  unknown
> = z.object({
  paths: z.array(z.lazy(() => UpdateMicrofrontendsPaths$inboundSchema)),
});

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsPassport$inboundSchema: z.ZodType<
  UpdateMicrofrontendsPassport,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: UpdateMicrofrontendsDeploymentType$inboundSchema,
  connectorId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsSandboxUrls$inboundSchema: z.ZodType<
  UpdateMicrofrontendsSandboxUrls,
  z.ZodTypeDef,
  unknown
> = z.object({
  inheritDeploymentProtection: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsProtectionConfig$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProtectionConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  sandboxUrls: types.optional(
    z.lazy(() => UpdateMicrofrontendsSandboxUrls$inboundSchema),
  ),
});

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsBuildQueue$inboundSchema: z.ZodType<
  UpdateMicrofrontendsBuildQueue,
  z.ZodTypeDef,
  unknown
> = z.object({
  configuration: types.optional(
    UpdateMicrofrontendsConfiguration$inboundSchema,
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsResourceConfig$inboundSchema: z.ZodType<
  UpdateMicrofrontendsResourceConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  elasticConcurrencyEnabled: types.optional(types.boolean()),
  fluid: types.optional(types.boolean()),
  functionDefaultRegions: z.array(types.string()),
  functionDefaultTimeout: types.optional(types.number()),
  functionDefaultMemoryType: types.optional(
    UpdateMicrofrontendsFunctionDefaultMemoryType$inboundSchema,
  ),
  functionZeroConfigFailover: types.optional(types.boolean()),
  buildMachineType: types.optional(
    UpdateMicrofrontendsBuildMachineType$inboundSchema,
  ),
  buildMachineSelection: types.optional(
    UpdateMicrofrontendsBuildMachineSelection$inboundSchema,
  ),
  buildMachineElasticLastUpdated: types.optional(types.number()),
  isNSNBDisabled: types.optional(types.boolean()),
  buildQueue: types.optional(
    z.lazy(() => UpdateMicrofrontendsBuildQueue$inboundSchema),
  ),
  enableFunctionsBeta: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsRollbackDescription$inboundSchema: z.ZodType<
  UpdateMicrofrontendsRollbackDescription,
  z.ZodTypeDef,
  unknown
> = z.object({
  userId: types.string(),
  username: types.string(),
  description: types.string(),
  createdAt: types.number(),
});

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

/** @internal */
export const UpdateMicrofrontendsStages$inboundSchema: z.ZodType<
  UpdateMicrofrontendsStages,
  z.ZodTypeDef,
  unknown
> = z.object({
  targetPercentage: types.number(),
  requireApproval: types.optional(types.boolean()),
  duration: types.optional(types.number()),
  linearShift: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsRollingRelease$inboundSchema: z.ZodType<
  UpdateMicrofrontendsRollingRelease,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.string(),
  stages: z.nullable(
    z.array(z.lazy(() => UpdateMicrofrontendsStages$inboundSchema)),
  ).optional(),
  canaryResponseHeader: types.optional(types.boolean()),
});

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsProjectsBuildQueue$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjectsBuildQueue,
  z.ZodTypeDef,
  unknown
> = z.object({
  configuration: types.optional(
    UpdateMicrofrontendsProjectsConfiguration$inboundSchema,
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsDefaultResourceConfig$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDefaultResourceConfig,
  z.ZodTypeDef,
  unknown
> = z.object({
  elasticConcurrencyEnabled: types.optional(types.boolean()),
  fluid: types.optional(types.boolean()),
  functionDefaultRegions: z.array(types.string()),
  functionDefaultTimeout: types.optional(types.number()),
  functionDefaultMemoryType: types.optional(
    UpdateMicrofrontendsProjectsFunctionDefaultMemoryType$inboundSchema,
  ),
  functionZeroConfigFailover: types.optional(types.boolean()),
  buildMachineType: types.optional(
    UpdateMicrofrontendsProjectsBuildMachineType$inboundSchema,
  ),
  buildMachineSelection: types.optional(
    UpdateMicrofrontendsProjectsBuildMachineSelection$inboundSchema,
  ),
  buildMachineElasticLastUpdated: types.optional(types.number()),
  isNSNBDisabled: types.optional(types.boolean()),
  buildQueue: types.optional(
    z.lazy(() => UpdateMicrofrontendsProjectsBuildQueue$inboundSchema),
  ),
  enableFunctionsBeta: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsStaticIps$inboundSchema: z.ZodType<
  UpdateMicrofrontendsStaticIps,
  z.ZodTypeDef,
  unknown
> = z.object({
  builds: types.boolean(),
  enabled: types.boolean(),
  regions: z.array(types.string()),
});

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsSsoProtection$inboundSchema: z.ZodType<
  UpdateMicrofrontendsSsoProtection,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: UpdateMicrofrontendsProjectsDeploymentType$inboundSchema,
  cve55182MigrationAppliedFrom: z.nullable(
    UpdateMicrofrontendsCve55182MigrationAppliedFrom$inboundSchema,
  ).optional(),
  april2026SecurityIncidentMigrationAppliedFrom: z.nullable(
    UpdateMicrofrontendsApril2026SecurityIncidentMigrationAppliedFrom$inboundSchema,
  ).optional(),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsProjectsBuilds$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjectsBuilds,
  z.ZodTypeDef,
  unknown
> = z.object({
  use: types.string(),
  src: types.optional(types.string()),
  dest: types.optional(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsProjectsCreator$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjectsCreator,
  z.ZodTypeDef,
  unknown
> = z.object({
  email: types.string(),
  githubLogin: types.optional(types.string()),
  gitlabLogin: types.optional(types.string()),
  uid: types.string(),
  username: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsTargets$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTargets,
  z.ZodTypeDef,
  unknown
> = z.object({
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  builds: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsProjectsBuilds$inboundSchema)),
  ),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UpdateMicrofrontendsProjectsCreator$inboundSchema),
  ),
  deploymentHostname: types.string(),
  name: types.string(),
  forced: types.optional(types.boolean()),
  id: types.string(),
  meta: types.optional(z.record(types.string())),
  plan: types.string(),
  private: types.boolean(),
  readyState: types.string(),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: types.string(),
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

/** @internal */
export const UpdateMicrofrontendsPermissions$inboundSchema: z.ZodType<
  UpdateMicrofrontendsPermissions,
  z.ZodTypeDef,
  unknown
> = z.object({
  oauth2Connection: types.optional(z.array(ACLAction$inboundSchema)),
  user: types.optional(z.array(ACLAction$inboundSchema)),
  userConnection: types.optional(z.array(ACLAction$inboundSchema)),
  userMfaConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  userPreference: types.optional(z.array(ACLAction$inboundSchema)),
  userSudo: types.optional(z.array(ACLAction$inboundSchema)),
  webAuthn: types.optional(z.array(ACLAction$inboundSchema)),
  accessGroup: types.optional(z.array(ACLAction$inboundSchema)),
  agent: types.optional(z.array(ACLAction$inboundSchema)),
  aiGatewayRules: types.optional(z.array(ACLAction$inboundSchema)),
  aiGatewayUsage: types.optional(z.array(ACLAction$inboundSchema)),
  alerts: types.optional(z.array(ACLAction$inboundSchema)),
  alertRules: types.optional(z.array(ACLAction$inboundSchema)),
  aliasGlobal: types.optional(z.array(ACLAction$inboundSchema)),
  analyticsSampling: types.optional(z.array(ACLAction$inboundSchema)),
  analyticsUsage: types.optional(z.array(ACLAction$inboundSchema)),
  apiKey: types.optional(z.array(ACLAction$inboundSchema)),
  apiKeyAiGateway: types.optional(z.array(ACLAction$inboundSchema)),
  apiKeyOwnedBySelf: types.optional(z.array(ACLAction$inboundSchema)),
  oauth2Application: types.optional(z.array(ACLAction$inboundSchema)),
  vercelAppInstallation: types.optional(z.array(ACLAction$inboundSchema)),
  vercelAppInstallationRequest: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  auditLog: types.optional(z.array(ACLAction$inboundSchema)),
  billingAddress: types.optional(z.array(ACLAction$inboundSchema)),
  billingInformation: types.optional(z.array(ACLAction$inboundSchema)),
  billingInvoice: types.optional(z.array(ACLAction$inboundSchema)),
  billingInvoiceEmailRecipient: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  billingInvoiceLanguage: types.optional(z.array(ACLAction$inboundSchema)),
  billingPlan: types.optional(z.array(ACLAction$inboundSchema)),
  billingPurchaseOrder: types.optional(z.array(ACLAction$inboundSchema)),
  billingRefund: types.optional(z.array(ACLAction$inboundSchema)),
  billingTaxId: types.optional(z.array(ACLAction$inboundSchema)),
  blob: types.optional(z.array(ACLAction$inboundSchema)),
  blobStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  budget: types.optional(z.array(ACLAction$inboundSchema)),
  cacheArtifact: types.optional(z.array(ACLAction$inboundSchema)),
  cacheArtifactUsageEvent: types.optional(z.array(ACLAction$inboundSchema)),
  codeChecks: types.optional(z.array(ACLAction$inboundSchema)),
  ciInvocations: types.optional(z.array(ACLAction$inboundSchema)),
  ciLogs: types.optional(z.array(ACLAction$inboundSchema)),
  concurrentBuilds: types.optional(z.array(ACLAction$inboundSchema)),
  connect: types.optional(z.array(ACLAction$inboundSchema)),
  connectConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  connexClient: types.optional(z.array(ACLAction$inboundSchema)),
  connexClientProject: types.optional(z.array(ACLAction$inboundSchema)),
  connexToken: types.optional(z.array(ACLAction$inboundSchema)),
  buildMachineDefault: types.optional(z.array(ACLAction$inboundSchema)),
  dataCacheBillingSettings: types.optional(z.array(ACLAction$inboundSchema)),
  defaultDeploymentProtection: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPolicy: types.optional(z.array(ACLAction$inboundSchema)),
  domain: types.optional(z.array(ACLAction$inboundSchema)),
  domainAcceptDelegation: types.optional(z.array(ACLAction$inboundSchema)),
  domainAuthCodes: types.optional(z.array(ACLAction$inboundSchema)),
  domainCertificate: types.optional(z.array(ACLAction$inboundSchema)),
  domainCheckConfig: types.optional(z.array(ACLAction$inboundSchema)),
  domainMove: types.optional(z.array(ACLAction$inboundSchema)),
  domainPurchase: types.optional(z.array(ACLAction$inboundSchema)),
  domainRecord: types.optional(z.array(ACLAction$inboundSchema)),
  domainTransferIn: types.optional(z.array(ACLAction$inboundSchema)),
  drain: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfig: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigItem: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigSchema: types.optional(z.array(ACLAction$inboundSchema)),
  edgeConfigToken: types.optional(z.array(ACLAction$inboundSchema)),
  endpointVerification: types.optional(z.array(ACLAction$inboundSchema)),
  event: types.optional(z.array(ACLAction$inboundSchema)),
  fileUpload: types.optional(z.array(ACLAction$inboundSchema)),
  flagsExplorerSubscription: types.optional(z.array(ACLAction$inboundSchema)),
  gitRepository: types.optional(z.array(ACLAction$inboundSchema)),
  imageOptimizationNewPrice: types.optional(z.array(ACLAction$inboundSchema)),
  integration: types.optional(z.array(ACLAction$inboundSchema)),
  integrationAccount: types.optional(z.array(ACLAction$inboundSchema)),
  integrationConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  integrationConfigurationProjects: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationConfigurationRole: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationConfigurationTransfer: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationDeploymentAction: types.optional(z.array(ACLAction$inboundSchema)),
  integrationEvent: types.optional(z.array(ACLAction$inboundSchema)),
  integrationLog: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResource: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResourceData: types.optional(z.array(ACLAction$inboundSchema)),
  integrationResourceReplCommand: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationResourceSecrets: types.optional(z.array(ACLAction$inboundSchema)),
  integrationSSOSession: types.optional(z.array(ACLAction$inboundSchema)),
  integrationStrict: types.optional(z.array(ACLAction$inboundSchema)),
  integrationStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  integrationVercelConfigurationOverride: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  integrationPullRequest: types.optional(z.array(ACLAction$inboundSchema)),
  ipBlocking: types.optional(z.array(ACLAction$inboundSchema)),
  jobGlobal: types.optional(z.array(ACLAction$inboundSchema)),
  kmsIssuer: types.optional(z.array(ACLAction$inboundSchema)),
  kmsProjectGrant: types.optional(z.array(ACLAction$inboundSchema)),
  logDrain: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceBillingData: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceExperimentationEdgeConfigData: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceExperimentationItem: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceInstallationMember: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  marketplaceInvoice: types.optional(z.array(ACLAction$inboundSchema)),
  marketplaceSettings: types.optional(z.array(ACLAction$inboundSchema)),
  Monitoring: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringAlert: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringChart: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringQuery: types.optional(z.array(ACLAction$inboundSchema)),
  monitoringSettings: types.optional(z.array(ACLAction$inboundSchema)),
  notificationCustomerBudget: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDeploymentFailed: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationDomainConfiguration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationDomainExpire: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainMoved: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainPurchase: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainRenewal: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  notificationDomainUnverified: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  NotificationMonitoringAlert: types.optional(z.array(ACLAction$inboundSchema)),
  notificationPaymentFailed: types.optional(z.array(ACLAction$inboundSchema)),
  notificationPreferences: types.optional(z.array(ACLAction$inboundSchema)),
  notificationStatementOfReasons: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  notificationUsageAlert: types.optional(z.array(ACLAction$inboundSchema)),
  oidcFederationPolicy: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityFunnel: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityNotebook: types.optional(z.array(ACLAction$inboundSchema)),
  openTelemetryEndpoint: types.optional(z.array(ACLAction$inboundSchema)),
  ownEvent: types.optional(z.array(ACLAction$inboundSchema)),
  organization: types.optional(z.array(ACLAction$inboundSchema)),
  organizationDomain: types.optional(z.array(ACLAction$inboundSchema)),
  organizationTeam: types.optional(z.array(ACLAction$inboundSchema)),
  passwordProtectionInvoiceItem: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  paymentMethod: types.optional(z.array(ACLAction$inboundSchema)),
  permissions: types.optional(z.array(ACLAction$inboundSchema)),
  postgres: types.optional(z.array(ACLAction$inboundSchema)),
  postgresStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  previewDeploymentSuffix: types.optional(z.array(ACLAction$inboundSchema)),
  privateCloudAccount: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransferIn: types.optional(z.array(ACLAction$inboundSchema)),
  proTrialOnboarding: types.optional(z.array(ACLAction$inboundSchema)),
  rateLimit: types.optional(z.array(ACLAction$inboundSchema)),
  redis: types.optional(z.array(ACLAction$inboundSchema)),
  redisStoreTokenSet: types.optional(z.array(ACLAction$inboundSchema)),
  remoteCaching: types.optional(z.array(ACLAction$inboundSchema)),
  repository: types.optional(z.array(ACLAction$inboundSchema)),
  samlConfig: types.optional(z.array(ACLAction$inboundSchema)),
  secret: types.optional(z.array(ACLAction$inboundSchema)),
  sensitiveEnvironmentVariablePolicy: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  sharedEnvVars: types.optional(z.array(ACLAction$inboundSchema)),
  sharedEnvVarsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  space: types.optional(z.array(ACLAction$inboundSchema)),
  spaceRun: types.optional(z.array(ACLAction$inboundSchema)),
  storeIsLocked: types.optional(z.array(ACLAction$inboundSchema)),
  storeTokenSetSensitive: types.optional(z.array(ACLAction$inboundSchema)),
  storeTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  supportCase: types.optional(z.array(ACLAction$inboundSchema)),
  supportCaseComment: types.optional(z.array(ACLAction$inboundSchema)),
  team: types.optional(z.array(ACLAction$inboundSchema)),
  teamAccessRequest: types.optional(z.array(ACLAction$inboundSchema)),
  teamFellowMembership: types.optional(z.array(ACLAction$inboundSchema)),
  teamGitExclusivity: types.optional(z.array(ACLAction$inboundSchema)),
  teamInvite: types.optional(z.array(ACLAction$inboundSchema)),
  teamInviteCode: types.optional(z.array(ACLAction$inboundSchema)),
  teamInviteLink: types.optional(z.array(ACLAction$inboundSchema)),
  teamJoin: types.optional(z.array(ACLAction$inboundSchema)),
  teamMemberMfaStatus: types.optional(z.array(ACLAction$inboundSchema)),
  teamMicrofrontends: types.optional(z.array(ACLAction$inboundSchema)),
  teamOwnMembership: types.optional(z.array(ACLAction$inboundSchema)),
  teamOwnMembershipDisconnectSAML: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  teamSudo: types.optional(z.array(ACLAction$inboundSchema)),
  teamTokenInvalidation: types.optional(z.array(ACLAction$inboundSchema)),
  token: types.optional(z.array(ACLAction$inboundSchema)),
  toolbarComment: types.optional(z.array(ACLAction$inboundSchema)),
  usage: types.optional(z.array(ACLAction$inboundSchema)),
  usageCycle: types.optional(z.array(ACLAction$inboundSchema)),
  vcrRepository: types.optional(z.array(ACLAction$inboundSchema)),
  vercelRun: types.optional(z.array(ACLAction$inboundSchema)),
  vpcPeeringConnection: types.optional(z.array(ACLAction$inboundSchema)),
  webAnalyticsPlan: types.optional(z.array(ACLAction$inboundSchema)),
  webhook: types.optional(z.array(ACLAction$inboundSchema)),
  "webhook-event": types.optional(z.array(ACLAction$inboundSchema)),
  aliasProject: types.optional(z.array(ACLAction$inboundSchema)),
  aliasProtectionBypass: types.optional(z.array(ACLAction$inboundSchema)),
  bulkRedirects: types.optional(z.array(ACLAction$inboundSchema)),
  buildMachine: types.optional(z.array(ACLAction$inboundSchema)),
  connectConfigurationLink: types.optional(z.array(ACLAction$inboundSchema)),
  dataCacheNamespace: types.optional(z.array(ACLAction$inboundSchema)),
  deployment: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentBuildLogs: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheck: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheckPreview: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentCheckReRunFromProductionBranch: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  deploymentProductionGit: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentV0: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPreview: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPrivate: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentPromote: types.optional(z.array(ACLAction$inboundSchema)),
  deploymentRollback: types.optional(z.array(ACLAction$inboundSchema)),
  edgeCacheNamespace: types.optional(z.array(ACLAction$inboundSchema)),
  environments: types.optional(z.array(ACLAction$inboundSchema)),
  job: types.optional(z.array(ACLAction$inboundSchema)),
  logs: types.optional(z.array(ACLAction$inboundSchema)),
  logsPreset: types.optional(z.array(ACLAction$inboundSchema)),
  observabilityData: types.optional(z.array(ACLAction$inboundSchema)),
  onDemandBuild: types.optional(z.array(ACLAction$inboundSchema)),
  onDemandConcurrency: types.optional(z.array(ACLAction$inboundSchema)),
  optionsAllowlist: types.optional(z.array(ACLAction$inboundSchema)),
  passwordProtection: types.optional(z.array(ACLAction$inboundSchema)),
  privateLinkEndpoint: types.optional(z.array(ACLAction$inboundSchema)),
  productionAliasProtectionBypass: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  project: types.optional(z.array(ACLAction$inboundSchema)),
  projectAccessGroup: types.optional(z.array(ACLAction$inboundSchema)),
  projectAnalyticsSampling: types.optional(z.array(ACLAction$inboundSchema)),
  projectAnalyticsUsage: types.optional(z.array(ACLAction$inboundSchema)),
  projectCheck: types.optional(z.array(ACLAction$inboundSchema)),
  projectCheckRun: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentExpiration: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentHook: types.optional(z.array(ACLAction$inboundSchema)),
  projectDeploymentProtectionStrict: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectDomain: types.optional(z.array(ACLAction$inboundSchema)),
  projectDomainCheckConfig: types.optional(z.array(ACLAction$inboundSchema)),
  projectDomainMove: types.optional(z.array(ACLAction$inboundSchema)),
  projectEvent: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVars: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVarsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  projectEnvVarsUnownedByIntegration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectFlags: types.optional(z.array(ACLAction$inboundSchema)),
  projectFlagsProduction: types.optional(z.array(ACLAction$inboundSchema)),
  projectFlagsSdkKey: types.optional(z.array(ACLAction$inboundSchema)),
  projectFromV0: types.optional(z.array(ACLAction$inboundSchema)),
  projectId: types.optional(z.array(ACLAction$inboundSchema)),
  projectIntegrationConfiguration: types.optional(
    z.array(ACLAction$inboundSchema),
  ),
  projectLink: types.optional(z.array(ACLAction$inboundSchema)),
  projectMember: types.optional(z.array(ACLAction$inboundSchema)),
  projectMonitoring: types.optional(z.array(ACLAction$inboundSchema)),
  projectOIDCToken: types.optional(z.array(ACLAction$inboundSchema)),
  projectPermissions: types.optional(z.array(ACLAction$inboundSchema)),
  projectProductionBranch: types.optional(z.array(ACLAction$inboundSchema)),
  projectProtectionBypass: types.optional(z.array(ACLAction$inboundSchema)),
  projectRollingRelease: types.optional(z.array(ACLAction$inboundSchema)),
  projectRoutes: types.optional(z.array(ACLAction$inboundSchema)),
  projectSupportCase: types.optional(z.array(ACLAction$inboundSchema)),
  projectSupportCaseComment: types.optional(z.array(ACLAction$inboundSchema)),
  projectTier: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransfer: types.optional(z.array(ACLAction$inboundSchema)),
  projectTransferOut: types.optional(z.array(ACLAction$inboundSchema)),
  projectUsage: types.optional(z.array(ACLAction$inboundSchema)),
  pageIntegrity: types.optional(z.array(ACLAction$inboundSchema)),
  seawallConfig: types.optional(z.array(ACLAction$inboundSchema)),
  securityPlusConfiguration: types.optional(z.array(ACLAction$inboundSchema)),
  shareableLinkStrict: types.optional(z.array(ACLAction$inboundSchema)),
  sharedEnvVarConnection: types.optional(z.array(ACLAction$inboundSchema)),
  skewProtection: types.optional(z.array(ACLAction$inboundSchema)),
  analytics: types.optional(z.array(ACLAction$inboundSchema)),
  trustedIps: types.optional(z.array(ACLAction$inboundSchema)),
  trustedSources: types.optional(z.array(ACLAction$inboundSchema)),
  v0Chat: types.optional(z.array(ACLAction$inboundSchema)),
  webAnalytics: types.optional(z.array(ACLAction$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "Monitoring": "monitoring",
    "NotificationMonitoringAlert": "notificationMonitoringAlert",
    "webhook-event": "webhookEvent",
    "projectFlagsSdkKey": "projectFlagsSDKKey",
  });
});

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsLastAliasRequest$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLastAliasRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  fromDeploymentId: types.nullable(types.string()),
  toDeploymentId: types.string(),
  fromRollingReleaseId: types.optional(types.string()),
  jobStatus: UpdateMicrofrontendsJobStatus$inboundSchema,
  requestedAt: types.number(),
  type: UpdateMicrofrontendsProjectsResponseType$inboundSchema,
});

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

/** @internal */
export const UpdateMicrofrontendsProtectionBypass2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProtectionBypass2,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.number(),
  createdBy: types.string(),
  scope: types.literal("automation-bypass"),
  isEnvVar: types.optional(types.boolean()),
  note: types.optional(types.string()),
});

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

/** @internal */
export const UpdateMicrofrontendsProtectionBypass1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProtectionBypass1,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdAt: types.number(),
  createdBy: types.string(),
  scope: types.literal("integration-automation-bypass"),
  integrationId: types.string(),
  configurationId: types.string(),
});

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

/** @internal */
export const UpdateMicrofrontendsProtectionBypass$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProtectionBypass,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateMicrofrontendsProtectionBypass1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsProtectionBypass2$inboundSchema),
]);

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsTrustedIpsAddresses$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTrustedIpsAddresses,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.string(),
  note: types.optional(types.string()),
});

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

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

/** @internal */
export const UpdateMicrofrontendsTrustedIps1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTrustedIps1,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType: UpdateMicrofrontendsTrustedIpsDeploymentType$inboundSchema,
  addresses: z.array(
    z.lazy(() => UpdateMicrofrontendsTrustedIpsAddresses$inboundSchema),
  ),
  protectionMode: UpdateMicrofrontendsTrustedIpsProtectionMode$inboundSchema,
});

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

/** @internal */
export const UpdateMicrofrontendsTrustedIps$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTrustedIps,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsTrustedIps1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsTrustedIps2$inboundSchema),
]);

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

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

/** @internal */
export const UpdateMicrofrontendsFrom2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsFrom2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: UpdateMicrofrontendsFromProjectsPreset$inboundSchema,
});

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

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

/** @internal */
export const UpdateMicrofrontendsFrom1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsFrom1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(UpdateMicrofrontendsFromPreset$inboundSchema),
});

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

/** @internal */
export const UpdateMicrofrontendsFrom$inboundSchema: z.ZodType<
  UpdateMicrofrontendsFrom,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsFrom1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsFrom2$inboundSchema),
]);

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

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

/** @internal */
export const UpdateMicrofrontendsToProjects2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsToProjects2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: UpdateMicrofrontendsToProjectsResponse200Preset$inboundSchema,
});

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

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

/** @internal */
export const UpdateMicrofrontendsToProjects1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsToProjects1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(
    UpdateMicrofrontendsToProjectsResponsePreset$inboundSchema,
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsProjectsTo$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjectsTo,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsToProjects1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsToProjects2$inboundSchema),
]);

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

/** @internal */
export const UpdateMicrofrontendsCustomAllow$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCustomAllow,
  z.ZodTypeDef,
  unknown
> = z.object({
  from: smartUnion([
    z.lazy(() => UpdateMicrofrontendsFrom1$inboundSchema),
    z.lazy(() => UpdateMicrofrontendsFrom2$inboundSchema),
  ]),
  to: smartUnion([
    z.lazy(() => UpdateMicrofrontendsToProjects1$inboundSchema),
    z.lazy(() => UpdateMicrofrontendsToProjects2$inboundSchema),
  ]),
});

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

/** @internal */
export const UpdateMicrofrontendsProjects$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjects,
  z.ZodTypeDef,
  unknown
> = z.object({
  label: types.optional(types.string()),
  customAllow: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsCustomAllow$inboundSchema)),
  ),
});

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

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

/** @internal */
export const UpdateMicrofrontendsTo2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTo2,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: types.optional(z.array(types.string())),
  preset: UpdateMicrofrontendsToProjectsPreset$inboundSchema,
});

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

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

/** @internal */
export const UpdateMicrofrontendsTo1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTo1,
  z.ZodTypeDef,
  unknown
> = z.object({
  slugs: z.array(types.string()),
  preset: types.optional(UpdateMicrofrontendsToPreset$inboundSchema),
});

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

/** @internal */
export const UpdateMicrofrontendsTo$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTo,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => UpdateMicrofrontendsTo1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsTo2$inboundSchema),
]);

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

/** @internal */
export const UpdateMicrofrontendsOidcProviders$inboundSchema: z.ZodType<
  UpdateMicrofrontendsOidcProviders,
  z.ZodTypeDef,
  unknown
> = z.object({
  to: smartUnion([
    z.lazy(() => UpdateMicrofrontendsTo1$inboundSchema),
    z.lazy(() => UpdateMicrofrontendsTo2$inboundSchema),
  ]),
  label: types.optional(types.string()),
  claims: z.record(z.array(types.string())),
});

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

/** @internal */
export const UpdateMicrofrontendsTrustedSources$inboundSchema: z.ZodType<
  UpdateMicrofrontendsTrustedSources,
  z.ZodTypeDef,
  unknown
> = z.object({
  projects: types.optional(
    z.record(z.lazy(() => UpdateMicrofrontendsProjects$inboundSchema)),
  ),
  oidcProviders: types.optional(
    z.record(z.array(z.lazy(() =>
      UpdateMicrofrontendsOidcProviders$inboundSchema
    ))),
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsGitComments$inboundSchema: z.ZodType<
  UpdateMicrofrontendsGitComments,
  z.ZodTypeDef,
  unknown
> = z.object({
  onPullRequest: types.boolean(),
  onCommit: types.boolean(),
});

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

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

/** @internal */
export const UpdateMicrofrontendsConsolidatedGitCommitStatus$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsConsolidatedGitCommitStatus,
    z.ZodTypeDef,
    unknown
  > = z.object({
    enabled: types.boolean(),
    propagateFailures: types.boolean(),
  });

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

/** @internal */
export const UpdateMicrofrontendsGitProviderOptions$inboundSchema: z.ZodType<
  UpdateMicrofrontendsGitProviderOptions,
  z.ZodTypeDef,
  unknown
> = z.object({
  createDeployments: UpdateMicrofrontendsCreateDeployments$inboundSchema,
  disableRepositoryDispatchEvents: types.optional(types.boolean()),
  requireVerifiedCommits: types.optional(types.boolean()),
  gitCommitStatus: types.optional(types.boolean()),
  consolidatedGitCommitStatus: types.optional(
    z.lazy(() => UpdateMicrofrontendsConsolidatedGitCommitStatus$inboundSchema),
  ),
});

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

/** @internal */
export const UpdateMicrofrontendsWebAnalytics$inboundSchema: z.ZodType<
  UpdateMicrofrontendsWebAnalytics,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  disabledAt: types.optional(types.number()),
  canceledAt: types.optional(types.number()),
  enabledAt: types.optional(types.number()),
  hasData: types.optional(types.literal(true)),
});

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

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

/** @internal */
export const UpdateMicrofrontendsVercelRuleset$inboundSchema: z.ZodType<
  UpdateMicrofrontendsVercelRuleset,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  action: types.optional(
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAction$inboundSchema,
  ),
});

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