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

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

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 UpdateMicrofrontendsCreator4 = {
  type: "system";
};

export type UpdateMicrofrontendsCreatorIntegration = {
  integrationId: string;
  configurationId: string;
};

export type UpdateMicrofrontendsCreator3 = {
  type: "integration";
  integration: UpdateMicrofrontendsCreatorIntegration;
};

export type UpdateMicrofrontendsCreatorApp = {
  /**
   * The internal ID of the Vercel App backing this principal.
   */
  id: string;
  /**
   * The protocol-facing OAuth client ID. This may differ from {@link id} when Client ID Metadata Documents (CIMD) are used.
   */
  clientId?: string | undefined;
};

export type UpdateMicrofrontendsCreator2 = {
  type: "app";
  app: UpdateMicrofrontendsCreatorApp;
};

export type UpdateMicrofrontendsViaIntegration = {
  integrationId: string;
  configurationId: string;
};

/**
 * Set when a Vercel App or Integration acts on behalf of a {@link User}. Captures user-consented OAuth delegation that the ACL layer may inspect to evaluate scope restrictions. This is NOT for impersonation or token-exchange provenance — those live on `auth.token`, not on the principal.
 */
export type UpdateMicrofrontendsVia2 = {
  type: "integration";
  integration: UpdateMicrofrontendsViaIntegration;
};

export type UpdateMicrofrontendsViaApp = {
  /**
   * The internal ID of the Vercel App backing this principal.
   */
  id: string;
  /**
   * The protocol-facing OAuth client ID. This may differ from {@link id} when Client ID Metadata Documents (CIMD) are used.
   */
  clientId?: string | undefined;
};

/**
 * Set when a Vercel App or Integration acts on behalf of a {@link User}. Captures user-consented OAuth delegation that the ACL layer may inspect to evaluate scope restrictions. This is NOT for impersonation or token-exchange provenance — those live on `auth.token`, not on the principal.
 */
export type UpdateMicrofrontendsVia1 = {
  type: "app";
  app: UpdateMicrofrontendsViaApp;
};

export type UpdateMicrofrontendsCreatorVia =
  | UpdateMicrofrontendsVia1
  | UpdateMicrofrontendsVia2;

export type UpdateMicrofrontendsCreatorUser = {
  id: string;
};

export type UpdateMicrofrontendsCreator1 = {
  type: "user";
  via: UpdateMicrofrontendsVia1 | UpdateMicrofrontendsVia2 | null;
  user: UpdateMicrofrontendsCreatorUser;
};

export type UpdateMicrofrontendsCreator =
  | UpdateMicrofrontendsCreator1
  | UpdateMicrofrontendsCreator2
  | UpdateMicrofrontendsCreator3
  | UpdateMicrofrontendsCreator4;

export const UpdateMicrofrontendsConfiguredBy = {
  A: "A",
  Cname: "CNAME",
  Dns01: "dns-01",
  Http: "http",
} as const;
export type UpdateMicrofrontendsConfiguredBy = ClosedEnum<
  typeof UpdateMicrofrontendsConfiguredBy
>;

export type UpdateMicrofrontendsProjectsResponseAliasAssigned =
  | number
  | boolean;

export type UpdateMicrofrontendsProjectsResponseAliasError = {
  code: string;
  message: string;
};

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

export type UpdateMicrofrontendsProjectsResponse200BranchMatcher = {
  /**
   * The type of matching to perform
   */
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasDeploymentType;
  /**
   * The pattern to match against branch names
   */
  pattern: string;
};

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

export const UpdateMicrofrontendsProjectsResponseChecksConclusion = {
  Canceled: "canceled",
  Failed: "failed",
  Skipped: "skipped",
  Succeeded: "succeeded",
} as const;
export type UpdateMicrofrontendsProjectsResponseChecksConclusion = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseChecksConclusion
>;

export const UpdateMicrofrontendsProjectsResponseChecksState = {
  Completed: "completed",
  Registered: "registered",
  Running: "running",
} as const;
export type UpdateMicrofrontendsProjectsResponseChecksState = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseChecksState
>;

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

export type UpdateMicrofrontendsProjectsResponseOidcTokenClaims = {
  iss: string;
  sub: string;
  scope: string;
  aud: string;
  owner: string;
  ownerId: string;
  project: string;
  projectId: string;
  environment: string;
  customEnvironmentId?: string | undefined;
  mfeGroupIds?: Array<string> | undefined;
  plan?: string | undefined;
};

export const UpdateMicrofrontendsProjectsResponsePlan = {
  Enterprise: "enterprise",
  Hobby: "hobby",
  Pro: "pro",
} as const;
export type UpdateMicrofrontendsProjectsResponsePlan = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponsePlan
>;

export const UpdateMicrofrontendsProjectsResponseReadyState = {
  Blocked: "BLOCKED",
  Building: "BUILDING",
  Canceled: "CANCELED",
  Error: "ERROR",
  Initializing: "INITIALIZING",
  Queued: "QUEUED",
  Ready: "READY",
} as const;
export type UpdateMicrofrontendsProjectsResponseReadyState = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseReadyState
>;

export const UpdateMicrofrontendsProjectsResponseReadySubstate = {
  Promoted: "PROMOTED",
  Rolling: "ROLLING",
  Staged: "STAGED",
} as const;
export type UpdateMicrofrontendsProjectsResponseReadySubstate = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseReadySubstate
>;

export const UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasType =
  {
    Lambdas: "LAMBDAS",
  } as const;
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasType =
  ClosedEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasType
  >;

export type UpdateMicrofrontendsDeployment = {
  id: string;
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  aliasError?:
    | UpdateMicrofrontendsProjectsResponseAliasError
    | null
    | undefined;
  aliasFinal?: string | null | undefined;
  automaticAliases?: Array<string> | undefined;
  branchMatcher?:
    | UpdateMicrofrontendsProjectsResponse200BranchMatcher
    | undefined;
  buildingAt?: number | undefined;
  builds?: Array<UpdateMicrofrontendsProjectsResponseBuilds> | undefined;
  checksConclusion?:
    | UpdateMicrofrontendsProjectsResponseChecksConclusion
    | undefined;
  checksState?: UpdateMicrofrontendsProjectsResponseChecksState | undefined;
  connectBuildsEnabled?: boolean | undefined;
  connectConfigurationId?: string | undefined;
  createdAt: number;
  createdIn: string;
  creator: UpdateMicrofrontendsProjectsResponse200Creator | null;
  deletedAt?: number | undefined;
  deploymentHostname: string;
  forced?: boolean | undefined;
  name: string;
  meta?: { [k: string]: string } | undefined;
  monorepoManager?: string | null | undefined;
  oidcTokenClaims?:
    | UpdateMicrofrontendsProjectsResponseOidcTokenClaims
    | undefined;
  plan: UpdateMicrofrontendsProjectsResponsePlan;
  /**
   * Whether or not preview comments are enabled for the deployment
   */
  previewCommentsEnabled?: boolean | undefined;
  private: boolean;
  readyAt?: number | undefined;
  readyState: UpdateMicrofrontendsProjectsResponseReadyState;
  readySubstate?: UpdateMicrofrontendsProjectsResponseReadySubstate | undefined;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasType;
  url: string;
  /**
   * Present for user creators; omitted for app/integration/system creators.
   */
  userId?: string | undefined;
  withCache?: boolean | undefined;
};

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

export const UpdateMicrofrontendsTarget = {
  Preview: "PREVIEW",
  Production: "PRODUCTION",
  Staging: "STAGING",
} as const;
export type UpdateMicrofrontendsTarget = ClosedEnum<
  typeof UpdateMicrofrontendsTarget
>;

export type UpdateMicrofrontendsAlias = {
  configuredBy?: UpdateMicrofrontendsConfiguredBy | null | undefined;
  configuredChangedAt?: number | null | undefined;
  createdAt?: number | null | undefined;
  deployment: UpdateMicrofrontendsDeployment | null;
  domain: string;
  environment: UpdateMicrofrontendsEnvironment;
  gitBranch?: string | null | undefined;
  redirect?: string | null | undefined;
  redirectStatusCode?: number | null | undefined;
  target: UpdateMicrofrontendsTarget;
};

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;
  /**
   * When the first free (not Speed Insights Plus) production data point was observed, in ms. Set once by subscriber-analytics-events; projects that already had data before this field shipped get it backfilled on their next batch, so it reads "first free data point observed", not necessarily "first ever".
   */
  dataReceivedAt?: number | 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 UpdateMicrofrontendsProjectsTarget =
  | Array<UpdateMicrofrontendsTarget1>
  | UpdateMicrofrontendsTarget2;

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

/**
 * User-facing config/secret model. When set, authoritative for new code paths when the env-var-config-secret-ui flag is enabled. Legacy rows omit this field; legacy rows omit it and callers fall back to existing `type` behavior.
 */
export const UpdateMicrofrontendsVisibility = {
  Config: "config",
  Secret: "secret",
} as const;
/**
 * User-facing config/secret model. When set, authoritative for new code paths when the env-var-config-secret-ui flag is enabled. Legacy rows omit this field; legacy rows omit it and callers fall back to existing `type` behavior.
 */
export type UpdateMicrofrontendsVisibility = ClosedEnum<
  typeof UpdateMicrofrontendsVisibility
>;

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 UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType =
  {
    FlagsSecret: "flags-secret",
  } as const;
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType =
  ClosedEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType
  >;

/**
 * Similar to `contentHints`, but should not be exposed to the user.
 */
export type UpdateMicrofrontendsInternalContentHint = {
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType;
  /**
   * 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;
  /**
   * User-facing config/secret model. When set, authoritative for new code paths when the env-var-config-secret-ui flag is enabled. Legacy rows omit this field; legacy rows omit it and callers fall back to existing `type` behavior.
   */
  visibility?: UpdateMicrofrontendsVisibility | 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 UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType =
  {
    EndsWith: "endsWith",
    Equals: "equals",
    StartsWith: "startsWith",
  } as const;
/**
 * The type of matching to perform
 */
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType =
  ClosedEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType
  >;

/**
 * Configuration for matching git branches to this environment
 */
export type UpdateMicrofrontendsBranchMatcher = {
  /**
   * The type of matching to perform
   */
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType;
  /**
   * 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",
  Container: "container",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  FactoryEve: "factory-eve",
  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",
  TanstackStartLovable: "tanstack-start-lovable",
  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",
  Container: "container",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  FactoryEve: "factory-eve",
  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",
  TanstackStartLovable: "tanstack-start-lovable",
  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 UpdateMicrofrontendsAliasError = {
  code: string;
  message: string;
};

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

export type UpdateMicrofrontendsProjectsBranchMatcher = {
  /**
   * The type of matching to perform
   */
  type: UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyType;
  /**
   * The pattern to match against branch names
   */
  pattern: string;
};

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

export const UpdateMicrofrontendsChecksConclusion = {
  Canceled: "canceled",
  Failed: "failed",
  Skipped: "skipped",
  Succeeded: "succeeded",
} as const;
export type UpdateMicrofrontendsChecksConclusion = ClosedEnum<
  typeof UpdateMicrofrontendsChecksConclusion
>;

export const UpdateMicrofrontendsChecksState = {
  Completed: "completed",
  Registered: "registered",
  Running: "running",
} as const;
export type UpdateMicrofrontendsChecksState = ClosedEnum<
  typeof UpdateMicrofrontendsChecksState
>;

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

export type UpdateMicrofrontendsOidcTokenClaims = {
  iss: string;
  sub: string;
  scope: string;
  aud: string;
  owner: string;
  ownerId: string;
  project: string;
  projectId: string;
  environment: string;
  customEnvironmentId?: string | undefined;
  mfeGroupIds?: Array<string> | undefined;
  plan?: string | undefined;
};

export const UpdateMicrofrontendsPlan = {
  Enterprise: "enterprise",
  Hobby: "hobby",
  Pro: "pro",
} as const;
export type UpdateMicrofrontendsPlan = ClosedEnum<
  typeof UpdateMicrofrontendsPlan
>;

export const UpdateMicrofrontendsReadyState = {
  Blocked: "BLOCKED",
  Building: "BUILDING",
  Canceled: "CANCELED",
  Error: "ERROR",
  Initializing: "INITIALIZING",
  Queued: "QUEUED",
  Ready: "READY",
} as const;
export type UpdateMicrofrontendsReadyState = ClosedEnum<
  typeof UpdateMicrofrontendsReadyState
>;

export const UpdateMicrofrontendsReadySubstate = {
  Promoted: "PROMOTED",
  Rolling: "ROLLING",
  Staged: "STAGED",
} as const;
export type UpdateMicrofrontendsReadySubstate = ClosedEnum<
  typeof UpdateMicrofrontendsReadySubstate
>;

export const UpdateMicrofrontendsProjectsResponseType = {
  Lambdas: "LAMBDAS",
} as const;
export type UpdateMicrofrontendsProjectsResponseType = ClosedEnum<
  typeof UpdateMicrofrontendsProjectsResponseType
>;

export type UpdateMicrofrontendsLatestDeployments = {
  id: string;
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  aliasError?: UpdateMicrofrontendsAliasError | null | undefined;
  aliasFinal?: string | null | undefined;
  automaticAliases?: Array<string> | undefined;
  branchMatcher?: UpdateMicrofrontendsProjectsBranchMatcher | undefined;
  buildingAt?: number | undefined;
  builds?: Array<UpdateMicrofrontendsBuilds> | undefined;
  checksConclusion?: UpdateMicrofrontendsChecksConclusion | undefined;
  checksState?: UpdateMicrofrontendsChecksState | undefined;
  connectBuildsEnabled?: boolean | undefined;
  connectConfigurationId?: string | undefined;
  createdAt: number;
  createdIn: string;
  creator: UpdateMicrofrontendsProjectsCreator | null;
  deletedAt?: number | undefined;
  deploymentHostname: string;
  forced?: boolean | undefined;
  name: string;
  meta?: { [k: string]: string } | undefined;
  monorepoManager?: string | null | undefined;
  oidcTokenClaims?: UpdateMicrofrontendsOidcTokenClaims | undefined;
  plan: UpdateMicrofrontendsPlan;
  /**
   * Whether or not preview comments are enabled for the deployment
   */
  previewCommentsEnabled?: boolean | undefined;
  private: boolean;
  readyAt?: number | undefined;
  readyState: UpdateMicrofrontendsReadyState;
  readySubstate?: UpdateMicrofrontendsReadySubstate | undefined;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: UpdateMicrofrontendsProjectsResponseType;
  url: string;
  /**
   * Present for user creators; omitted for app/integration/system creators.
   */
  userId?: string | undefined;
  withCache?: boolean | undefined;
};

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

export type UpdateMicrofrontendsLink8 = {
  /**
   * Owner (namespace) slug, e.g. `acme`.
   */
  owner: string;
  repo: string;
  /**
   * Origin repository id.
   */
  repoId: string;
  /**
   * Origin namespace id (`ns_…`) of the owner.
   */
  ownerId: string;
  type: "cursor-origin";
  createdAt?: number | undefined;
  deployHooks: Array<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBody8DeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type UpdateMicrofrontendsLink7 = {
  org: string;
  repo: string;
  repoId: string;
  type: "v0";
  createdAt?: number | undefined;
  deployHooks: Array<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBody7DeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type UpdateMicrofrontendsLink6 = {
  org: string;
  repo: string;
  repoId: 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
  | UpdateMicrofrontendsLink7
  | UpdateMicrofrontendsLink8;

export type UpdateMicrofrontendsBlobs = {
  /**
   * Marks the team-level, Vercel-managed default blob project (`vercel-blob-default-project`) that orphan blob stores are scoped to when connected without an explicit project. Set only by internal storage flows and immutable after creation — guards rely on it to protect the connected stores from being lost when the project is deleted or transferred.
   */
  isDefaultApp?: boolean | undefined;
};

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 UpdateMicrofrontendsRegion = {
  Arn1: "arn1",
  Bom1: "bom1",
  Cdg1: "cdg1",
  Cle1: "cle1",
  Cpt1: "cpt1",
  Dub1: "dub1",
  Fra1: "fra1",
  Gru1: "gru1",
  Hkg1: "hkg1",
  Hnd1: "hnd1",
  Iad1: "iad1",
  Icn1: "icn1",
  Kix1: "kix1",
  Lhr1: "lhr1",
  Pdx1: "pdx1",
  Sfo1: "sfo1",
  Sin1: "sin1",
  Syd1: "syd1",
  Yul1: "yul1",
} as const;
export type UpdateMicrofrontendsRegion = ClosedEnum<
  typeof UpdateMicrofrontendsRegion
>;

export const UpdateMicrofrontendsFailoverRegions = {
  Arn1: "arn1",
  Bom1: "bom1",
  Cdg1: "cdg1",
  Cle1: "cle1",
  Cpt1: "cpt1",
  Dub1: "dub1",
  Fra1: "fra1",
  Gru1: "gru1",
  Hkg1: "hkg1",
  Hnd1: "hnd1",
  Iad1: "iad1",
  Icn1: "icn1",
  Kix1: "kix1",
  Lhr1: "lhr1",
  Pdx1: "pdx1",
  Sfo1: "sfo1",
  Sin1: "sin1",
  Syd1: "syd1",
  Yul1: "yul1",
} as const;
export type UpdateMicrofrontendsFailoverRegions = ClosedEnum<
  typeof UpdateMicrofrontendsFailoverRegions
>;

export type UpdateMicrofrontendsSandbox = {
  region?: UpdateMicrofrontendsRegion | undefined;
  failoverRegions?: Array<UpdateMicrofrontendsFailoverRegions> | 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 = {
  Basic: "basic",
  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 UpdateMicrofrontendsBuildMachineElasticReason = {
  BasicFloor: "basic-floor",
  BuildTimeoutFailure: "build-timeout-failure",
  EnospcFailure: "enospc-failure",
  EnterpriseFloor: "enterprise-floor",
  HighPeakDisk: "high-peak-disk",
  HighPeakMemory: "high-peak-memory",
  LongBuildDuration: "long-build-duration",
  OomFailure: "oom-failure",
  ShortBuildDuration: "short-build-duration",
  SustainedHighCpu: "sustained-high-cpu",
} as const;
export type UpdateMicrofrontendsBuildMachineElasticReason = ClosedEnum<
  typeof UpdateMicrofrontendsBuildMachineElasticReason
>;

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;
  buildMachineElasticReason?:
    | UpdateMicrofrontendsBuildMachineElasticReason
    | 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;
};

/**
 * The metric this check evaluates.
 */
export const UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType =
  {
    ErrorRate5xx: "error-rate-5xx",
  } as const;
/**
 * The metric this check evaluates.
 */
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType =
  ClosedEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType
  >;

/**
 * The checks to evaluate. An empty array means nothing is evaluated.
 */
export type UpdateMicrofrontendsChecks = {
  /**
   * The metric this check evaluates.
   */
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType;
  /**
   * Minimum number of requests required in the window before the check can fail. Below this, the check is inconclusive rather than failing, so low-traffic stages don't gate on noise. Defaults to `100` when omitted.
   */
  minSampleSize?: number | undefined;
  /**
   * Response status codes to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Defaults to `[]` when omitted.
   */
  excludeStatusCodes?: Array<number> | undefined;
  /**
   * Request paths to ignore entirely — dropped from both the numerator (errors) and the denominator (total requests). Matched exactly against the request path with any query string removed; no prefix or glob matching. Defaults to `[]` when omitted.
   */
  excludePaths?: Array<string> | undefined;
  /**
   * Seconds of ingest lag to allow for: the query's upper bound is `now() - this value`, so the check never reads a window that is still filling. Defaults to `30` when omitted.
   */
  ingestWatermarkSeconds?: number | undefined;
};

/**
 * What to do when the gate trips: pause the rollout, or roll it back.
 */
export const UpdateMicrofrontendsProjectsResponse200ApplicationJSONAction = {
  Pause: "pause",
  Rollback: "rollback",
} as const;
/**
 * What to do when the gate trips: pause the rollout, or roll it back.
 */
export type UpdateMicrofrontendsProjectsResponse200ApplicationJSONAction =
  ClosedEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONAction
  >;

/**
 * Automated gating configuration. Omitted (the default) means no gating is configured, which is equivalent to `enabled: false`.
 */
export type UpdateMicrofrontendsGate = {
  /**
   * Whether automated gating is enabled for this project's rollouts.
   */
  enabled: boolean;
  /**
   * The checks to evaluate. An empty array means nothing is evaluated.
   */
  checks: Array<UpdateMicrofrontendsChecks>;
  /**
   * How many failing evaluations within {@link windowSize} trip the gate. Defaults to `3` when omitted.
   */
  failureThreshold?: number | undefined;
  /**
   * How many of the most recent evaluations {@link failureThreshold} is counted against. Defaults to `5` when omitted.
   */
  windowSize?: number | undefined;
  /**
   * What to do when the gate trips: pause the rollout, or roll it back.
   */
  action: UpdateMicrofrontendsProjectsResponse200ApplicationJSONAction;
  /**
   * When true, a tripped gate is only reported — {@link action} is not taken.
   */
  dryRun: boolean;
};

/**
 * 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;
  /**
   * Automated gating configuration. Omitted (the default) means no gating is configured, which is equivalent to `enabled: false`.
   */
  gate?: UpdateMicrofrontendsGate | undefined;
};

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

/** @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 UpdateMicrofrontendsCreator4$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("system"),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsCreator3$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("integration"),
  integration: z.lazy(() =>
    UpdateMicrofrontendsCreatorIntegration$inboundSchema
  ),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsCreator2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("app"),
  app: z.lazy(() => UpdateMicrofrontendsCreatorApp$inboundSchema),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsVia2$inboundSchema: z.ZodType<
  UpdateMicrofrontendsVia2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("integration"),
  integration: z.lazy(() => UpdateMicrofrontendsViaIntegration$inboundSchema),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsVia1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsVia1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("app"),
  app: z.lazy(() => UpdateMicrofrontendsViaApp$inboundSchema),
});

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsCreator1$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("user"),
  via: types.nullable(
    z.union([
      z.lazy(() => UpdateMicrofrontendsVia1$inboundSchema),
      z.lazy(() => UpdateMicrofrontendsVia2$inboundSchema),
    ]),
  ),
  user: z.lazy(() => UpdateMicrofrontendsCreatorUser$inboundSchema),
});

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

/** @internal */
export const UpdateMicrofrontendsCreator$inboundSchema: z.ZodType<
  UpdateMicrofrontendsCreator,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateMicrofrontendsCreator1$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsCreator2$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsCreator3$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsCreator4$inboundSchema),
]);

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 UpdateMicrofrontendsConfiguredBy$inboundSchema: z.ZodNativeEnum<
  typeof UpdateMicrofrontendsConfiguredBy
> = z.nativeEnum(UpdateMicrofrontendsConfiguredBy);

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsProjectsResponse200Creator$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsProjectsResponse200Creator,
    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 updateMicrofrontendsProjectsResponse200CreatorFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateMicrofrontendsProjectsResponse200Creator,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateMicrofrontendsProjectsResponse200Creator$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateMicrofrontendsProjectsResponse200Creator' from JSON`,
  );
}

/** @internal */
export const UpdateMicrofrontendsProjectsResponseOidcTokenClaims$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsProjectsResponseOidcTokenClaims,
    z.ZodTypeDef,
    unknown
  > = z.object({
    iss: types.string(),
    sub: types.string(),
    scope: types.string(),
    aud: types.string(),
    owner: types.string(),
    owner_id: types.string(),
    project: types.string(),
    project_id: types.string(),
    environment: types.string(),
    custom_environment_id: types.optional(types.string()),
    mfe_group_ids: types.optional(z.array(types.string())),
    plan: types.optional(types.string()),
  }).transform((v) => {
    return remap$(v, {
      "owner_id": "ownerId",
      "project_id": "projectId",
      "custom_environment_id": "customEnvironmentId",
      "mfe_group_ids": "mfeGroupIds",
    });
  });

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsDeployment$inboundSchema: z.ZodType<
  UpdateMicrofrontendsDeployment,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  aliasError: z.nullable(
    z.lazy(() => UpdateMicrofrontendsProjectsResponseAliasError$inboundSchema),
  ).optional(),
  aliasFinal: z.nullable(types.string()).optional(),
  automaticAliases: types.optional(z.array(types.string())),
  branchMatcher: types.optional(
    z.lazy(() =>
      UpdateMicrofrontendsProjectsResponse200BranchMatcher$inboundSchema
    ),
  ),
  buildingAt: types.optional(types.number()),
  builds: types.optional(
    z.array(z.lazy(() =>
      UpdateMicrofrontendsProjectsResponseBuilds$inboundSchema
    )),
  ),
  checksConclusion: types.optional(
    UpdateMicrofrontendsProjectsResponseChecksConclusion$inboundSchema,
  ),
  checksState: types.optional(
    UpdateMicrofrontendsProjectsResponseChecksState$inboundSchema,
  ),
  connectBuildsEnabled: types.optional(types.boolean()),
  connectConfigurationId: types.optional(types.string()),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UpdateMicrofrontendsProjectsResponse200Creator$inboundSchema),
  ),
  deletedAt: types.optional(types.number()),
  deploymentHostname: types.string(),
  forced: types.optional(types.boolean()),
  name: types.string(),
  meta: types.optional(z.record(types.string())),
  monorepoManager: z.nullable(types.string()).optional(),
  oidcTokenClaims: types.optional(
    z.lazy(() =>
      UpdateMicrofrontendsProjectsResponseOidcTokenClaims$inboundSchema
    ),
  ),
  plan: UpdateMicrofrontendsProjectsResponsePlan$inboundSchema,
  previewCommentsEnabled: types.optional(types.boolean()),
  private: types.boolean(),
  readyAt: types.optional(types.number()),
  readyState: UpdateMicrofrontendsProjectsResponseReadyState$inboundSchema,
  readySubstate: types.optional(
    UpdateMicrofrontendsProjectsResponseReadySubstate$inboundSchema,
  ),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyAliasType$inboundSchema,
  url: types.string(),
  userId: types.optional(types.string()),
  withCache: types.optional(types.boolean()),
});

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

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

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

/** @internal */
export const UpdateMicrofrontendsAlias$inboundSchema: z.ZodType<
  UpdateMicrofrontendsAlias,
  z.ZodTypeDef,
  unknown
> = z.object({
  configuredBy: z.nullable(UpdateMicrofrontendsConfiguredBy$inboundSchema)
    .optional(),
  configuredChangedAt: z.nullable(types.number()).optional(),
  createdAt: z.nullable(types.number()).optional(),
  deployment: types.nullable(
    z.lazy(() => UpdateMicrofrontendsDeployment$inboundSchema),
  ),
  domain: types.string(),
  environment: UpdateMicrofrontendsEnvironment$inboundSchema,
  gitBranch: z.nullable(types.string()).optional(),
  redirect: z.nullable(types.string()).optional(),
  redirectStatusCode: z.nullable(types.number()).optional(),
  target: UpdateMicrofrontendsTarget$inboundSchema,
});

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

/** @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()),
  dataReceivedAt: types.optional(types.number()),
  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 UpdateMicrofrontendsProjectsTarget$inboundSchema: z.ZodType<
  UpdateMicrofrontendsProjectsTarget,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.array(UpdateMicrofrontendsTarget1$inboundSchema),
  UpdateMicrofrontendsTarget2$inboundSchema,
]);

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

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

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

/** @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 UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType
  > = z.nativeEnum(
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType,
  );

/** @internal */
export const UpdateMicrofrontendsInternalContentHint$inboundSchema: z.ZodType<
  UpdateMicrofrontendsInternalContentHint,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyEnvType$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()),
  visibility: types.optional(UpdateMicrofrontendsVisibility$inboundSchema),
  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 UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType
  > = z.nativeEnum(
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType,
  );

/** @internal */
export const UpdateMicrofrontendsBranchMatcher$inboundSchema: z.ZodType<
  UpdateMicrofrontendsBranchMatcher,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyCustomEnvironmentsType$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 UpdateMicrofrontendsAliasError$inboundSchema: z.ZodType<
  UpdateMicrofrontendsAliasError,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.string(),
  message: types.string(),
});

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

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

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

export function updateMicrofrontendsProjectsBranchMatcherFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateMicrofrontendsProjectsBranchMatcher,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateMicrofrontendsProjectsBranchMatcher$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateMicrofrontendsProjectsBranchMatcher' 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 UpdateMicrofrontendsChecksConclusion$inboundSchema:
  z.ZodNativeEnum<typeof UpdateMicrofrontendsChecksConclusion> = z.nativeEnum(
    UpdateMicrofrontendsChecksConclusion,
  );

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

/** @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 UpdateMicrofrontendsOidcTokenClaims$inboundSchema: z.ZodType<
  UpdateMicrofrontendsOidcTokenClaims,
  z.ZodTypeDef,
  unknown
> = z.object({
  iss: types.string(),
  sub: types.string(),
  scope: types.string(),
  aud: types.string(),
  owner: types.string(),
  owner_id: types.string(),
  project: types.string(),
  project_id: types.string(),
  environment: types.string(),
  custom_environment_id: types.optional(types.string()),
  mfe_group_ids: types.optional(z.array(types.string())),
  plan: types.optional(types.string()),
}).transform((v) => {
  return remap$(v, {
    "owner_id": "ownerId",
    "project_id": "projectId",
    "custom_environment_id": "customEnvironmentId",
    "mfe_group_ids": "mfeGroupIds",
  });
});

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

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

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

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

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

/** @internal */
export const UpdateMicrofrontendsLatestDeployments$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLatestDeployments,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  alias: types.optional(z.array(types.string())),
  aliasAssigned: z.nullable(smartUnion([types.number(), types.boolean()]))
    .optional(),
  aliasError: z.nullable(
    z.lazy(() => UpdateMicrofrontendsAliasError$inboundSchema),
  ).optional(),
  aliasFinal: z.nullable(types.string()).optional(),
  automaticAliases: types.optional(z.array(types.string())),
  branchMatcher: types.optional(
    z.lazy(() => UpdateMicrofrontendsProjectsBranchMatcher$inboundSchema),
  ),
  buildingAt: types.optional(types.number()),
  builds: types.optional(
    z.array(z.lazy(() => UpdateMicrofrontendsBuilds$inboundSchema)),
  ),
  checksConclusion: types.optional(
    UpdateMicrofrontendsChecksConclusion$inboundSchema,
  ),
  checksState: types.optional(UpdateMicrofrontendsChecksState$inboundSchema),
  connectBuildsEnabled: types.optional(types.boolean()),
  connectConfigurationId: types.optional(types.string()),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => UpdateMicrofrontendsProjectsCreator$inboundSchema),
  ),
  deletedAt: types.optional(types.number()),
  deploymentHostname: types.string(),
  forced: types.optional(types.boolean()),
  name: types.string(),
  meta: types.optional(z.record(types.string())),
  monorepoManager: z.nullable(types.string()).optional(),
  oidcTokenClaims: types.optional(
    z.lazy(() => UpdateMicrofrontendsOidcTokenClaims$inboundSchema),
  ),
  plan: UpdateMicrofrontendsPlan$inboundSchema,
  previewCommentsEnabled: types.optional(types.boolean()),
  private: types.boolean(),
  readyAt: types.optional(types.number()),
  readyState: UpdateMicrofrontendsReadyState$inboundSchema,
  readySubstate: types.optional(
    UpdateMicrofrontendsReadySubstate$inboundSchema,
  ),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: UpdateMicrofrontendsProjectsResponseType$inboundSchema,
  url: types.string(),
  userId: types.optional(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 UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBody8DeployHooks$inboundSchema:
  z.ZodType<
    UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBody8DeployHooks,
    z.ZodTypeDef,
    unknown
  > = z.object({
    createdAt: types.optional(types.number()),
    id: types.string(),
    name: types.string(),
    ref: types.string(),
    url: types.string(),
  });

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

/** @internal */
export const UpdateMicrofrontendsLink8$inboundSchema: z.ZodType<
  UpdateMicrofrontendsLink8,
  z.ZodTypeDef,
  unknown
> = z.object({
  owner: types.string(),
  repo: types.string(),
  repoId: types.string(),
  ownerId: types.string(),
  type: types.literal("cursor-origin"),
  createdAt: types.optional(types.number()),
  deployHooks: z.array(
    z.lazy(() =>
      UpdateMicrofrontendsLinkProjectsResponse200ApplicationJSONResponseBody8DeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

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

export function updateMicrofrontendsLink7FromJSON(
  jsonString: string,
): SafeParseResult<UpdateMicrofrontendsLink7, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateMicrofrontendsLink7$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateMicrofrontendsLink7' 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(),
  repoId: 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),
  z.lazy(() => UpdateMicrofrontendsLink7$inboundSchema),
  z.lazy(() => UpdateMicrofrontendsLink8$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 UpdateMicrofrontendsBlobs$inboundSchema: z.ZodType<
  UpdateMicrofrontendsBlobs,
  z.ZodTypeDef,
  unknown
> = z.object({
  isDefaultApp: types.optional(types.boolean()),
});

export function updateMicrofrontendsBlobsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateMicrofrontendsBlobs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateMicrofrontendsBlobs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateMicrofrontendsBlobs' 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 UpdateMicrofrontendsRegion$inboundSchema: z.ZodNativeEnum<
  typeof UpdateMicrofrontendsRegion
> = z.nativeEnum(UpdateMicrofrontendsRegion);

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

/** @internal */
export const UpdateMicrofrontendsSandbox$inboundSchema: z.ZodType<
  UpdateMicrofrontendsSandbox,
  z.ZodTypeDef,
  unknown
> = z.object({
  region: types.optional(UpdateMicrofrontendsRegion$inboundSchema),
  failoverRegions: types.optional(
    z.array(UpdateMicrofrontendsFailoverRegions$inboundSchema),
  ),
});

export function updateMicrofrontendsSandboxFromJSON(
  jsonString: string,
): SafeParseResult<UpdateMicrofrontendsSandbox, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateMicrofrontendsSandbox$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateMicrofrontendsSandbox' 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 UpdateMicrofrontendsBuildMachineElasticReason$inboundSchema:
  z.ZodNativeEnum<typeof UpdateMicrofrontendsBuildMachineElasticReason> = z
    .nativeEnum(UpdateMicrofrontendsBuildMachineElasticReason);

/** @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()),
  buildMachineElasticReason: types.optional(
    UpdateMicrofrontendsBuildMachineElasticReason$inboundSchema,
  ),
  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 UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType
  > = z.nativeEnum(
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType,
  );

/** @internal */
export const UpdateMicrofrontendsChecks$inboundSchema: z.ZodType<
  UpdateMicrofrontendsChecks,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONResponseBodyRollingReleaseType$inboundSchema,
  minSampleSize: types.optional(types.number()),
  excludeStatusCodes: types.optional(z.array(types.number())),
  excludePaths: types.optional(z.array(types.string())),
  ingestWatermarkSeconds: types.optional(types.number()),
});

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

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

/** @internal */
export const UpdateMicrofrontendsGate$inboundSchema: z.ZodType<
  UpdateMicrofrontendsGate,
  z.ZodTypeDef,
  unknown
> = z.object({
  enabled: types.boolean(),
  checks: z.array(z.lazy(() => UpdateMicrofrontendsChecks$inboundSchema)),
  failureThreshold: types.optional(types.number()),
  windowSize: types.optional(types.number()),
  action:
    UpdateMicrofrontendsProjectsResponse200ApplicationJSONAction$inboundSchema,
  dryRun: types.boolean(),
});

export function updateMicrofrontendsGateFromJSON(
  jsonString: string,
): SafeParseResult<UpdateMicrofrontendsGate, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateMicrofrontendsGate$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateMicrofrontendsGate' 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()),
  gate: types.optional(z.lazy(() => UpdateMicrofrontendsGate$inboundSchema)),
});

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);