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

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

export type GetMicrofrontendsInGroupRequest = {
  groupId: 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;
};

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

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

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

export type GetMicrofrontendsInGroupEnvId =
  | string
  | GetMicrofrontendsInGroupEnvId2;

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

export type GetMicrofrontendsInGroupConnectConfigurations = {
  envId: string | GetMicrofrontendsInGroupEnvId2;
  connectConfigurationId: string;
  dc?: string | undefined;
  passive: boolean;
  buildsEnabled: boolean;
  aws?: GetMicrofrontendsInGroupAws | 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 GetMicrofrontendsInGroupSource = {
  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 GetMicrofrontendsInGroupSource = ClosedEnum<
  typeof GetMicrofrontendsInGroupSource
>;

export type GetMicrofrontendsInGroupDefinitions = {
  /**
   * 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?: GetMicrofrontendsInGroupSource | 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 GetMicrofrontendsInGroupCrons = {
  /**
   * 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<GetMicrofrontendsInGroupDefinitions>;
};

export type GetMicrofrontendsInGroupDataCache = {
  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 GetMicrofrontendsInGroupDeploymentExpiration = {
  /**
   * 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 GetMicrofrontendsInGroupExpiration2 = {
  /**
   * 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 GetMicrofrontendsInGroupExpiration1 = {
  /**
   * Unix ms timestamp when the project is scheduled to expire.
   */
  expiresAt: number;
};

export type GetMicrofrontendsInGroupExpiration =
  | GetMicrofrontendsInGroupExpiration2
  | GetMicrofrontendsInGroupExpiration1;

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

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

export type GetMicrofrontendsInGroupTarget =
  | Array<GetMicrofrontendsInGroupTarget1>
  | GetMicrofrontendsInGroupTarget2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export type GetMicrofrontendsInGroupContentHint =
  | GetMicrofrontendsInGroupContentHint1
  | GetMicrofrontendsInGroupContentHint2
  | GetMicrofrontendsInGroupContentHint3
  | GetMicrofrontendsInGroupContentHint4
  | GetMicrofrontendsInGroupContentHint5
  | GetMicrofrontendsInGroupContentHint6
  | GetMicrofrontendsInGroupContentHint7
  | GetMicrofrontendsInGroupContentHint8
  | GetMicrofrontendsInGroupContentHint9
  | GetMicrofrontendsInGroupContentHint10
  | GetMicrofrontendsInGroupContentHint11
  | GetMicrofrontendsInGroupContentHint12
  | GetMicrofrontendsInGroupContentHint13
  | GetMicrofrontendsInGroupContentHint14
  | GetMicrofrontendsInGroupContentHint15
  | GetMicrofrontendsInGroupContentHint16
  | GetMicrofrontendsInGroupContentHint17;

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

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

export type GetMicrofrontendsInGroupEnv = {
  target?:
    | Array<GetMicrofrontendsInGroupTarget1>
    | GetMicrofrontendsInGroupTarget2
    | undefined;
  type: GetMicrofrontendsInGroupType;
  /**
   * This is used to identify variables that have been migrated from type secret to sensitive.
   */
  sunsetSecretId?: string | undefined;
  /**
   * Legacy now-encryption ciphertext, present after migration swaps value/vsmValue
   */
  legacyValue?: string | undefined;
  decrypted?: boolean | undefined;
  value: string;
  vsmValue?: string | undefined;
  id?: string | undefined;
  key: string;
  configurationId?: string | null | undefined;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  createdBy?: string | null | undefined;
  updatedBy?: string | null | undefined;
  gitBranch?: string | undefined;
  edgeConfigId?: string | null | undefined;
  edgeConfigTokenId?: string | null | undefined;
  contentHint?:
    | GetMicrofrontendsInGroupContentHint1
    | GetMicrofrontendsInGroupContentHint2
    | GetMicrofrontendsInGroupContentHint3
    | GetMicrofrontendsInGroupContentHint4
    | GetMicrofrontendsInGroupContentHint5
    | GetMicrofrontendsInGroupContentHint6
    | GetMicrofrontendsInGroupContentHint7
    | GetMicrofrontendsInGroupContentHint8
    | GetMicrofrontendsInGroupContentHint9
    | GetMicrofrontendsInGroupContentHint10
    | GetMicrofrontendsInGroupContentHint11
    | GetMicrofrontendsInGroupContentHint12
    | GetMicrofrontendsInGroupContentHint13
    | GetMicrofrontendsInGroupContentHint14
    | GetMicrofrontendsInGroupContentHint15
    | GetMicrofrontendsInGroupContentHint16
    | GetMicrofrontendsInGroupContentHint17
    | null
    | undefined;
  /**
   * Similar to `contentHints`, but should not be exposed to the user.
   */
  internalContentHint?:
    | GetMicrofrontendsInGroupInternalContentHint
    | null
    | undefined;
  comment?: string | undefined;
  customEnvironmentIds?: Array<string> | undefined;
};

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

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

/**
 * Configuration for matching git branches to this environment
 */
export type GetMicrofrontendsInGroupBranchMatcher = {
  /**
   * The type of matching to perform
   */
  type:
    GetMicrofrontendsInGroupMicrofrontendsResponse200ApplicationJSONResponseBodyProjectsCustomEnvironmentsType;
  /**
   * 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 GetMicrofrontendsInGroupVerification = {
  type: string;
  domain: string;
  value: string;
  reason: string;
};

/**
 * List of domains associated with this environment
 */
export type GetMicrofrontendsInGroupDomains = {
  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<GetMicrofrontendsInGroupVerification> | undefined;
};

/**
 * Internal representation of a custom environment with all required properties
 */
export type GetMicrofrontendsInGroupCustomEnvironments = {
  /**
   * 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: GetMicrofrontendsInGroupMicrofrontendsType;
  /**
   * Optional description of the environment's purpose
   */
  description?: string | undefined;
  /**
   * Configuration for matching git branches to this environment
   */
  branchMatcher?: GetMicrofrontendsInGroupBranchMatcher | undefined;
  /**
   * List of domains associated with this environment
   */
  domains?: Array<GetMicrofrontendsInGroupDomains> | 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 GetMicrofrontendsInGroupFramework = {
  ActixWeb: "actix-web",
  Angular: "angular",
  Ash: "ash",
  Astro: "astro",
  Axum: "axum",
  Blitzjs: "blitzjs",
  Brunch: "brunch",
  Bun: "bun",
  CreateReactApp: "create-react-app",
  Django: "django",
  Docusaurus: "docusaurus",
  Docusaurus2: "docusaurus-2",
  Dojo: "dojo",
  Eleventy: "eleventy",
  Elysia: "elysia",
  Ember: "ember",
  Eve: "eve",
  Express: "express",
  Fastapi: "fastapi",
  Fasthtml: "fasthtml",
  Fastify: "fastify",
  Flask: "flask",
  Gatsby: "gatsby",
  Go: "go",
  Gridsome: "gridsome",
  H3: "h3",
  Hexo: "hexo",
  Hono: "hono",
  Hugo: "hugo",
  Hydrogen: "hydrogen",
  IonicAngular: "ionic-angular",
  IonicReact: "ionic-react",
  Jekyll: "jekyll",
  Koa: "koa",
  Mastra: "mastra",
  Middleman: "middleman",
  Nestjs: "nestjs",
  Nextjs: "nextjs",
  Nitro: "nitro",
  Node: "node",
  Nuxtjs: "nuxtjs",
  Parcel: "parcel",
  Polymer: "polymer",
  Preact: "preact",
  Python: "python",
  ReactRouter: "react-router",
  Redwoodjs: "redwoodjs",
  Remix: "remix",
  Ruby: "ruby",
  Rust: "rust",
  Saber: "saber",
  Sanity: "sanity",
  SanityV2: "sanity-v2",
  Sapper: "sapper",
  Scully: "scully",
  Services: "services",
  Solidstart: "solidstart",
  Solidstart1: "solidstart-1",
  Stencil: "stencil",
  Storybook: "storybook",
  Svelte: "svelte",
  Sveltekit: "sveltekit",
  Sveltekit1: "sveltekit-1",
  TanstackStart: "tanstack-start",
  Umijs: "umijs",
  Vite: "vite",
  Vitepress: "vitepress",
  Vue: "vue",
  Vuepress: "vuepress",
  Xmcp: "xmcp",
  Zola: "zola",
} as const;
export type GetMicrofrontendsInGroupFramework = ClosedEnum<
  typeof GetMicrofrontendsInGroupFramework
>;

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

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

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

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

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

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

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

export type GetMicrofrontendsInGroupJobs = {
  lint?: GetMicrofrontendsInGroupLint | undefined;
  typecheck?: GetMicrofrontendsInGroupTypecheck | undefined;
  mfeConfigPresent?: GetMicrofrontendsInGroupMfeConfigPresent | undefined;
};

export type GetMicrofrontendsInGroupMicrofrontendsAliasAssigned =
  | number
  | boolean;

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

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

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

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

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

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

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

export type GetMicrofrontendsInGroupOidcTokenClaims = {
  iss: string;
  sub: string;
  scope: string;
  aud: string;
  owner: string;
  ownerId: string;
  project: string;
  projectId: string;
  environment: string;
  customEnvironmentId?: string | undefined;
  plan?: string | undefined;
};

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

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

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

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

export type GetMicrofrontendsInGroupLatestDeployments = {
  id: string;
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  aliasError?: GetMicrofrontendsInGroupAliasError | null | undefined;
  aliasFinal?: string | null | undefined;
  automaticAliases?: Array<string> | undefined;
  branchMatcher?:
    | GetMicrofrontendsInGroupMicrofrontendsBranchMatcher
    | undefined;
  buildingAt?: number | undefined;
  builds?: Array<GetMicrofrontendsInGroupBuilds> | undefined;
  checksConclusion?: GetMicrofrontendsInGroupChecksConclusion | undefined;
  checksState?: GetMicrofrontendsInGroupChecksState | undefined;
  connectBuildsEnabled?: boolean | undefined;
  connectConfigurationId?: string | undefined;
  createdAt: number;
  createdIn: string;
  creator: GetMicrofrontendsInGroupCreator | null;
  deletedAt?: number | undefined;
  deploymentHostname: string;
  forced?: boolean | undefined;
  name: string;
  meta?: { [k: string]: string } | undefined;
  monorepoManager?: string | null | undefined;
  oidcTokenClaims?: GetMicrofrontendsInGroupOidcTokenClaims | undefined;
  plan: GetMicrofrontendsInGroupPlan;
  /**
   * Whether or not preview comments are enabled for the deployment
   */
  previewCommentsEnabled?: boolean | undefined;
  private: boolean;
  readyAt?: number | undefined;
  readyState: GetMicrofrontendsInGroupReadyState;
  readySubstate?: GetMicrofrontendsInGroupReadySubstate | undefined;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: GetMicrofrontendsInGroupMicrofrontendsResponseType;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

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

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

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

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

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

export type GetMicrofrontendsInGroupLink4 = {
  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<GetMicrofrontendsInGroupLinkMicrofrontendsDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type GetMicrofrontendsInGroupLink3 = {
  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<GetMicrofrontendsInGroupLinkDeployHooks>;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type GetMicrofrontendsInGroupLink2 = {
  type: "github-limited";
  createdAt?: 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;
  repo?: string | undefined;
  repoId?: number | undefined;
  deployHooks: Array<
    GetMicrofrontendsInGroupLinkMicrofrontendsResponse200ApplicationJSONResponseBodyDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

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

export type GetMicrofrontendsInGroupLink1 = {
  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<
    GetMicrofrontendsInGroupLinkMicrofrontendsResponse200ApplicationJSONDeployHooks
  >;
  gitCredentialId: string;
  updatedAt?: number | undefined;
  sourceless?: boolean | undefined;
  productionBranch: string;
};

export type GetMicrofrontendsInGroupLink =
  | GetMicrofrontendsInGroupLink1
  | GetMicrofrontendsInGroupLink2
  | GetMicrofrontendsInGroupLink3
  | GetMicrofrontendsInGroupLink4
  | GetMicrofrontendsInGroupLink5
  | GetMicrofrontendsInGroupLink6;

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

export type GetMicrofrontendsInGroupMicrofrontends2 = {
  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 GetMicrofrontendsInGroupMicrofrontends1 = {
  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 GetMicrofrontendsInGroupMicrofrontends =
  | GetMicrofrontendsInGroupMicrofrontends1
  | GetMicrofrontendsInGroupMicrofrontends2
  | GetMicrofrontendsInGroupMicrofrontends3;

export const GetMicrofrontendsInGroupNodeVersion = {
  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 GetMicrofrontendsInGroupNodeVersion = ClosedEnum<
  typeof GetMicrofrontendsInGroupNodeVersion
>;

export type GetMicrofrontendsInGroupPaths = {
  value: string;
};

export type GetMicrofrontendsInGroupOptionsAllowlist = {
  paths: Array<GetMicrofrontendsInGroupPaths>;
};

export type GetMicrofrontendsInGroupPasswordProtection = {};

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

export type GetMicrofrontendsInGroupPassport = {
  deploymentType: GetMicrofrontendsInGroupDeploymentType;
  connectorId: string;
};

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

export type GetMicrofrontendsInGroupProtectionConfig = {
  sandboxUrls?: GetMicrofrontendsInGroupSandboxUrls | undefined;
};

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

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

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

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

export type GetMicrofrontendsInGroupBuildQueue = {
  configuration?: GetMicrofrontendsInGroupConfiguration | undefined;
};

export type GetMicrofrontendsInGroupResourceConfig = {
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | GetMicrofrontendsInGroupMicrofrontendsFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  elasticConcurrencyEnabled?: boolean | undefined;
  buildMachineType?:
    | GetMicrofrontendsInGroupMicrofrontendsBuildMachineType
    | undefined;
  buildMachineSelection?:
    | GetMicrofrontendsInGroupMicrofrontendsBuildMachineSelection
    | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: GetMicrofrontendsInGroupBuildQueue | 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 GetMicrofrontendsInGroupRollbackDescription = {
  /**
   * 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 GetMicrofrontendsInGroupStages = {
  /**
   * The percentage of traffic to serve to the canary deployment (0-100)
   */
  targetPercentage: number;
  /**
   * Whether or not this stage requires manual approval to proceed
   */
  requireApproval?: boolean | undefined;
  /**
   * Duration in minutes for automatic advancement to the next stage
   */
  duration?: number | undefined;
  /**
   * Whether to linearly shift traffic over the duration of this stage
   */
  linearShift?: boolean | undefined;
};

/**
 * Project-level rolling release configuration that defines how deployments should be gradually rolled out
 */
export type GetMicrofrontendsInGroupRollingRelease = {
  /**
   * 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<GetMicrofrontendsInGroupStages> | null | undefined;
  /**
   * Whether the request served by a canary deployment should return a header indicating a canary was served. Defaults to `false` when omitted.
   */
  canaryResponseHeader?: boolean | undefined;
};

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

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

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

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

export type GetMicrofrontendsInGroupMicrofrontendsBuildQueue = {
  configuration?:
    | GetMicrofrontendsInGroupMicrofrontendsConfiguration
    | undefined;
};

export type GetMicrofrontendsInGroupDefaultResourceConfig = {
  fluid?: boolean | undefined;
  functionDefaultRegions: Array<string>;
  functionDefaultTimeout?: number | undefined;
  functionDefaultMemoryType?:
    | GetMicrofrontendsInGroupFunctionDefaultMemoryType
    | undefined;
  functionZeroConfigFailover?: boolean | undefined;
  elasticConcurrencyEnabled?: boolean | undefined;
  buildMachineType?: GetMicrofrontendsInGroupBuildMachineType | undefined;
  buildMachineSelection?:
    | GetMicrofrontendsInGroupBuildMachineSelection
    | undefined;
  buildMachineElasticLastUpdated?: number | undefined;
  isNSNBDisabled?: boolean | undefined;
  buildQueue?: GetMicrofrontendsInGroupMicrofrontendsBuildQueue | undefined;
  enableFunctionsBeta?: boolean | undefined;
};

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

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

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

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

export type GetMicrofrontendsInGroupSsoProtection = {
  deploymentType: GetMicrofrontendsInGroupMicrofrontendsDeploymentType;
  cve55182MigrationAppliedFrom?:
    | GetMicrofrontendsInGroupCve55182MigrationAppliedFrom
    | null
    | undefined;
  april2026SecurityIncidentMigrationAppliedFrom?:
    | GetMicrofrontendsInGroupApril2026SecurityIncidentMigrationAppliedFrom
    | null
    | undefined;
};

export type GetMicrofrontendsInGroupAliasAssigned = number | boolean;

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

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

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

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

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

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

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

export type GetMicrofrontendsInGroupMicrofrontendsOidcTokenClaims = {
  iss: string;
  sub: string;
  scope: string;
  aud: string;
  owner: string;
  ownerId: string;
  project: string;
  projectId: string;
  environment: string;
  customEnvironmentId?: string | undefined;
  plan?: string | undefined;
};

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

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

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

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

export type GetMicrofrontendsInGroupTargets = {
  id: string;
  alias?: Array<string> | undefined;
  aliasAssigned?: number | boolean | null | undefined;
  aliasError?:
    | GetMicrofrontendsInGroupMicrofrontendsAliasError
    | null
    | undefined;
  aliasFinal?: string | null | undefined;
  automaticAliases?: Array<string> | undefined;
  branchMatcher?:
    | GetMicrofrontendsInGroupMicrofrontendsResponseBranchMatcher
    | undefined;
  buildingAt?: number | undefined;
  builds?: Array<GetMicrofrontendsInGroupMicrofrontendsBuilds> | undefined;
  checksConclusion?:
    | GetMicrofrontendsInGroupMicrofrontendsChecksConclusion
    | undefined;
  checksState?: GetMicrofrontendsInGroupMicrofrontendsChecksState | undefined;
  connectBuildsEnabled?: boolean | undefined;
  connectConfigurationId?: string | undefined;
  createdAt: number;
  createdIn: string;
  creator: GetMicrofrontendsInGroupMicrofrontendsCreator | null;
  deletedAt?: number | undefined;
  deploymentHostname: string;
  forced?: boolean | undefined;
  name: string;
  meta?: { [k: string]: string } | undefined;
  monorepoManager?: string | null | undefined;
  oidcTokenClaims?:
    | GetMicrofrontendsInGroupMicrofrontendsOidcTokenClaims
    | undefined;
  plan: GetMicrofrontendsInGroupMicrofrontendsPlan;
  /**
   * Whether or not preview comments are enabled for the deployment
   */
  previewCommentsEnabled?: boolean | undefined;
  private: boolean;
  readyAt?: number | undefined;
  readyState: GetMicrofrontendsInGroupMicrofrontendsReadyState;
  readySubstate?:
    | GetMicrofrontendsInGroupMicrofrontendsReadySubstate
    | undefined;
  requestedAt?: number | undefined;
  target?: string | null | undefined;
  teamId?: string | null | undefined;
  type: GetMicrofrontendsInGroupMicrofrontendsResponse200Type;
  url: string;
  userId: string;
  withCache?: boolean | undefined;
};

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

export type GetMicrofrontendsInGroupLastRollbackTarget = {};

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

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

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

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

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

export type GetMicrofrontendsInGroupProtectionBypass =
  | GetMicrofrontendsInGroupProtectionBypass1
  | GetMicrofrontendsInGroupProtectionBypass2;

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

export type GetMicrofrontendsInGroupTrustedIps2 = {
  deploymentType: GetMicrofrontendsInGroupTrustedIpsDeploymentType;
};

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

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

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

export type GetMicrofrontendsInGroupTrustedIps1 = {
  deploymentType:
    GetMicrofrontendsInGroupTrustedIpsMicrofrontendsDeploymentType;
  addresses: Array<GetMicrofrontendsInGroupTrustedIpsAddresses>;
  protectionMode: GetMicrofrontendsInGroupTrustedIpsProtectionMode;
};

export type GetMicrofrontendsInGroupTrustedIps =
  | GetMicrofrontendsInGroupTrustedIps1
  | GetMicrofrontendsInGroupTrustedIps2;

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

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

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

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

export type GetMicrofrontendsInGroupFrom =
  | GetMicrofrontendsInGroupFrom1
  | GetMicrofrontendsInGroupFrom2;

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

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

/** @internal */
export type GetMicrofrontendsInGroupRequest$Outbound = {
  groupId: string;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const GetMicrofrontendsInGroupRequest$outboundSchema: z.ZodType<
  GetMicrofrontendsInGroupRequest$Outbound,
  z.ZodTypeDef,
  GetMicrofrontendsInGroupRequest
> = z.object({
  groupId: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function getMicrofrontendsInGroupRequestToJSON(
  getMicrofrontendsInGroupRequest: GetMicrofrontendsInGroupRequest,
): string {
  return JSON.stringify(
    GetMicrofrontendsInGroupRequest$outboundSchema.parse(
      getMicrofrontendsInGroupRequest,
    ),
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupCrons$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupCrons,
  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(() => GetMicrofrontendsInGroupDefinitions$inboundSchema),
  ),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupContentHint$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupContentHint,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetMicrofrontendsInGroupContentHint1$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint2$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint3$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint4$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint5$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint6$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint7$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint8$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint9$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint10$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint11$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint12$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint13$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint14$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint15$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint16$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupContentHint17$inboundSchema),
]);

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupEnv$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupEnv,
  z.ZodTypeDef,
  unknown
> = z.object({
  target: types.optional(
    smartUnion([
      z.array(GetMicrofrontendsInGroupTarget1$inboundSchema),
      GetMicrofrontendsInGroupTarget2$inboundSchema,
    ]),
  ),
  type: GetMicrofrontendsInGroupType$inboundSchema,
  sunsetSecretId: types.optional(types.string()),
  legacyValue: types.optional(types.string()),
  decrypted: types.optional(types.boolean()),
  value: types.string(),
  vsmValue: types.optional(types.string()),
  id: types.optional(types.string()),
  key: types.string(),
  configurationId: z.nullable(types.string()).optional(),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  createdBy: z.nullable(types.string()).optional(),
  updatedBy: z.nullable(types.string()).optional(),
  gitBranch: types.optional(types.string()),
  edgeConfigId: z.nullable(types.string()).optional(),
  edgeConfigTokenId: z.nullable(types.string()).optional(),
  contentHint: z.nullable(
    z.union([
      z.lazy(() => GetMicrofrontendsInGroupContentHint1$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint2$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint3$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint4$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint5$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint6$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint7$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint8$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint9$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint10$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint11$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint12$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint13$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint14$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint15$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint16$inboundSchema),
      z.lazy(() => GetMicrofrontendsInGroupContentHint17$inboundSchema),
    ]),
  ).optional(),
  internalContentHint: z.nullable(
    z.lazy(() => GetMicrofrontendsInGroupInternalContentHint$inboundSchema),
  ).optional(),
  comment: types.optional(types.string()),
  customEnvironmentIds: types.optional(z.array(types.string())),
});

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupDomains$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupDomains,
  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(() => GetMicrofrontendsInGroupVerification$inboundSchema)),
  ),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupOidcTokenClaims$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupOidcTokenClaims,
  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()),
  plan: types.optional(types.string()),
}).transform((v) => {
  return remap$(v, {
    "owner_id": "ownerId",
    "project_id": "projectId",
    "custom_environment_id": "customEnvironmentId",
  });
});

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupLatestDeployments$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLatestDeployments,
  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(() => GetMicrofrontendsInGroupAliasError$inboundSchema),
  ).optional(),
  aliasFinal: z.nullable(types.string()).optional(),
  automaticAliases: types.optional(z.array(types.string())),
  branchMatcher: types.optional(
    z.lazy(() =>
      GetMicrofrontendsInGroupMicrofrontendsBranchMatcher$inboundSchema
    ),
  ),
  buildingAt: types.optional(types.number()),
  builds: types.optional(
    z.array(z.lazy(() => GetMicrofrontendsInGroupBuilds$inboundSchema)),
  ),
  checksConclusion: types.optional(
    GetMicrofrontendsInGroupChecksConclusion$inboundSchema,
  ),
  checksState: types.optional(
    GetMicrofrontendsInGroupChecksState$inboundSchema,
  ),
  connectBuildsEnabled: types.optional(types.boolean()),
  connectConfigurationId: types.optional(types.string()),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => GetMicrofrontendsInGroupCreator$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(() => GetMicrofrontendsInGroupOidcTokenClaims$inboundSchema),
  ),
  plan: GetMicrofrontendsInGroupPlan$inboundSchema,
  previewCommentsEnabled: types.optional(types.boolean()),
  private: types.boolean(),
  readyAt: types.optional(types.number()),
  readyState: GetMicrofrontendsInGroupReadyState$inboundSchema,
  readySubstate: types.optional(
    GetMicrofrontendsInGroupReadySubstate$inboundSchema,
  ),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: GetMicrofrontendsInGroupMicrofrontendsResponseType$inboundSchema,
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupLink5$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLink5,
  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(() =>
      GetMicrofrontendsInGroupLinkMicrofrontendsResponseDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupLink4$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLink4,
  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(() =>
      GetMicrofrontendsInGroupLinkMicrofrontendsDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupLink3$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLink3,
  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(() => GetMicrofrontendsInGroupLinkDeployHooks$inboundSchema),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupLink1$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLink1,
  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(() =>
      GetMicrofrontendsInGroupLinkMicrofrontendsResponse200ApplicationJSONDeployHooks$inboundSchema
    ),
  ),
  gitCredentialId: types.string(),
  updatedAt: types.optional(types.number()),
  sourceless: types.optional(types.boolean()),
  productionBranch: types.string(),
});

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

/** @internal */
export const GetMicrofrontendsInGroupLink$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupLink,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetMicrofrontendsInGroupLink1$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupLink2$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupLink3$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupLink4$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupLink5$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupLink6$inboundSchema),
]);

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupMicrofrontends$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupMicrofrontends,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetMicrofrontendsInGroupMicrofrontends1$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupMicrofrontends2$inboundSchema),
  z.lazy(() => GetMicrofrontendsInGroupMicrofrontends3$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupSsoProtection$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupSsoProtection,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType:
    GetMicrofrontendsInGroupMicrofrontendsDeploymentType$inboundSchema,
  cve55182MigrationAppliedFrom: z.nullable(
    GetMicrofrontendsInGroupCve55182MigrationAppliedFrom$inboundSchema,
  ).optional(),
  april2026SecurityIncidentMigrationAppliedFrom: z.nullable(
    GetMicrofrontendsInGroupApril2026SecurityIncidentMigrationAppliedFrom$inboundSchema,
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupMicrofrontendsOidcTokenClaims$inboundSchema:
  z.ZodType<
    GetMicrofrontendsInGroupMicrofrontendsOidcTokenClaims,
    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()),
    plan: types.optional(types.string()),
  }).transform((v) => {
    return remap$(v, {
      "owner_id": "ownerId",
      "project_id": "projectId",
      "custom_environment_id": "customEnvironmentId",
    });
  });

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupTargets$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupTargets,
  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(() =>
      GetMicrofrontendsInGroupMicrofrontendsAliasError$inboundSchema
    ),
  ).optional(),
  aliasFinal: z.nullable(types.string()).optional(),
  automaticAliases: types.optional(z.array(types.string())),
  branchMatcher: types.optional(
    z.lazy(() =>
      GetMicrofrontendsInGroupMicrofrontendsResponseBranchMatcher$inboundSchema
    ),
  ),
  buildingAt: types.optional(types.number()),
  builds: types.optional(
    z.array(z.lazy(() =>
      GetMicrofrontendsInGroupMicrofrontendsBuilds$inboundSchema
    )),
  ),
  checksConclusion: types.optional(
    GetMicrofrontendsInGroupMicrofrontendsChecksConclusion$inboundSchema,
  ),
  checksState: types.optional(
    GetMicrofrontendsInGroupMicrofrontendsChecksState$inboundSchema,
  ),
  connectBuildsEnabled: types.optional(types.boolean()),
  connectConfigurationId: types.optional(types.string()),
  createdAt: types.number(),
  createdIn: types.string(),
  creator: types.nullable(
    z.lazy(() => GetMicrofrontendsInGroupMicrofrontendsCreator$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(() =>
      GetMicrofrontendsInGroupMicrofrontendsOidcTokenClaims$inboundSchema
    ),
  ),
  plan: GetMicrofrontendsInGroupMicrofrontendsPlan$inboundSchema,
  previewCommentsEnabled: types.optional(types.boolean()),
  private: types.boolean(),
  readyAt: types.optional(types.number()),
  readyState: GetMicrofrontendsInGroupMicrofrontendsReadyState$inboundSchema,
  readySubstate: types.optional(
    GetMicrofrontendsInGroupMicrofrontendsReadySubstate$inboundSchema,
  ),
  requestedAt: types.optional(types.number()),
  target: z.nullable(types.string()).optional(),
  teamId: z.nullable(types.string()).optional(),
  type: GetMicrofrontendsInGroupMicrofrontendsResponse200Type$inboundSchema,
  url: types.string(),
  userId: types.string(),
  withCache: types.optional(types.boolean()),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const GetMicrofrontendsInGroupTrustedIps1$inboundSchema: z.ZodType<
  GetMicrofrontendsInGroupTrustedIps1,
  z.ZodTypeDef,
  unknown
> = z.object({
  deploymentType:
    GetMicrofrontendsInGroupTrustedIpsMicrofrontendsDeploymentType$inboundSchema,
  addresses: z.array(
    z.lazy(() => GetMicrofrontendsInGroupTrustedIpsAddresses$inboundSchema),
  ),
  protectionMode:
    GetMicrofrontendsInGroupTrustedIpsProtectionMode$inboundSchema,
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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