/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 * @generated-id: 39fbf31160eb
 */

import * as z from "zod/v4";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import {
  DeploymentPortalAccentColor,
  DeploymentPortalAccentColor$inboundSchema,
} from "./deploymentportalaccentcolor.js";
import {
  DeploymentPortalAppearancePreset,
  DeploymentPortalAppearancePreset$inboundSchema,
} from "./deploymentportalappearancepreset.js";
import {
  DeploymentPortalDensity,
  DeploymentPortalDensity$inboundSchema,
} from "./deploymentportaldensity.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import {
  ProjectReleaseInfo,
  ProjectReleaseInfo$inboundSchema,
} from "./projectreleaseinfo.js";

/**
 * The Git Provider of the repository
 */
export const ProjectListItemResponseType = {
  Github: "github",
} as const;
/**
 * The Git Provider of the repository
 */
export type ProjectListItemResponseType = ClosedEnum<
  typeof ProjectListItemResponseType
>;

/**
 * Verified source repository connected to the project. Alien uses this for GitHub Actions setup and source-aware features; releases are still created explicitly by CI or `alien release`.
 */
export type ProjectListItemResponseGitRepository = {
  /**
   * The Git Provider of the repository
   */
  type: ProjectListItemResponseType;
  /**
   * The name of the git repository
   */
  repo: string;
};

/**
 * Customer-facing deployment portal appearance settings.
 */
export type ProjectListItemResponseDeploymentPortalAppearance = {
  /**
   * Optional project-specific avatar override for the deployment portal.
   */
  avatarUrl?: string | null | undefined;
  /**
   * Curated visual style for the deployment portal.
   */
  preset: DeploymentPortalAppearancePreset;
  /**
   * Accent color used for highlights and primary actions.
   */
  accentColor: DeploymentPortalAccentColor;
  /**
   * Optional portal title. Defaults to the project name.
   */
  title?: string | null | undefined;
  /**
   * Optional customer-facing subtitle.
   */
  subtitle?: string | null | undefined;
  /**
   * Optional support or contact URL.
   */
  supportUrl?: string | null | undefined;
  /**
   * Optional documentation URL.
   */
  docsUrl?: string | null | undefined;
  /**
   * Layout density for portal content.
   */
  density: DeploymentPortalDensity;
};

/**
 * Target OS and architecture for compiled binaries.
 *
 * @remarks
 *
 * Used as keys in package output maps (CLI binaries, Terraform providers, etc.)
 * and for cross-compilation target selection during builds.
 */
export const ProjectListItemResponseBinaryTarget = {
  WindowsX64: "windows-x64",
  LinuxX64: "linux-x64",
  LinuxArm64: "linux-arm64",
  DarwinArm64: "darwin-arm64",
} as const;
/**
 * Target OS and architecture for compiled binaries.
 *
 * @remarks
 *
 * Used as keys in package output maps (CLI binaries, Terraform providers, etc.)
 * and for cross-compilation target selection during builds.
 */
export type ProjectListItemResponseBinaryTarget = ClosedEnum<
  typeof ProjectListItemResponseBinaryTarget
>;

/**
 * CLI package configuration. If null, CLI packages will not be generated.
 */
export type ProjectListItemResponseCli = {
  /**
   * Binary targets required by this package's setup consumer.
   *
   * @remarks
   *
   * Older package rows omit this field and retain the historical all-target
   * behavior. Callers creating new packages should state their target set.
   */
  binaryTargets?: Array<ProjectListItemResponseBinaryTarget> | undefined;
  /**
   * Human-friendly display name for help banners and about text
   */
  displayName: string;
  /**
   * Binary name displayed in help and usage (e.g., "acmectl")
   */
  name: string;
  /**
   * Whether CLI package generation is enabled
   */
  enabled: boolean;
};

/**
 * CloudFormation package configuration. If null, CloudFormation packages will not be generated.
 */
export type ProjectListItemResponseCloudformation = {
  /**
   * Whether CloudFormation package generation is enabled
   */
  enabled: boolean;
  /**
   * Human-friendly application name shown in generated install artifacts
   */
  displayName?: string | null | undefined;
};

/**
 * Operator image package configuration. Required when Helm is enabled. If null, Operator image packages will not be generated.
 */
export type ProjectListItemResponseOperatorImage = {
  /**
   * Short brand slug used for generated resource names.
   */
  brand?: string | null | undefined;
  /**
   * Human-friendly display name for logs and startup messages
   */
  displayName: string;
  /**
   * Branded environment variable prefix (e.g., "ACME").
   */
  envPrefix?: string | null | undefined;
  /**
   * Branded Kubernetes/cloud label domain (e.g., "acme.dev").
   */
  labelDomain?: string | null | undefined;
  /**
   * Image name (e.g., "acme-operator")
   */
  name: string;
  /**
   * Whether Operator image package generation is enabled
   */
  enabled: boolean;
};

/**
 * Helm chart package configuration. If null, Helm packages will not be generated.
 */
export type ProjectListItemResponseHelm = {
  /**
   * Chart name (e.g., "acme-operator")
   */
  chartName: string;
  /**
   * Human-friendly description of the chart
   */
  description: string;
  /**
   * Whether Helm chart package generation is enabled
   */
  enabled: boolean;
};

/**
 * Terraform package configuration. If null, Terraform packages will not be generated.
 */
export type ProjectListItemResponseTerraform = {
  /**
   * Whether Terraform package generation is enabled
   */
  enabled: boolean;
  /**
   * Human-friendly application name shown in generated install artifacts
   */
  displayName?: string | null | undefined;
};

/**
 * Configuration for embedded packages (CLI, CloudFormation, Helm, Terraform)
 */
export type ProjectListItemResponsePackagesConfig = {
  /**
   * CLI package configuration. If null, CLI packages will not be generated.
   */
  cli?: ProjectListItemResponseCli | null | undefined;
  /**
   * CloudFormation package configuration. If null, CloudFormation packages will not be generated.
   */
  cloudformation?: ProjectListItemResponseCloudformation | null | undefined;
  /**
   * Operator image package configuration. Required when Helm is enabled. If null, Operator image packages will not be generated.
   */
  operatorImage?: ProjectListItemResponseOperatorImage | null | undefined;
  /**
   * Helm chart package configuration. If null, Helm packages will not be generated.
   */
  helm?: ProjectListItemResponseHelm | null | undefined;
  /**
   * Terraform package configuration. If null, Terraform packages will not be generated.
   */
  terraform?: ProjectListItemResponseTerraform | null | undefined;
};

/**
 * Project default private managers for new push deployments.
 */
export type ProjectListItemResponseDefaultManagers = {
  /**
   * Unique identifier for a default private manager.
   */
  aws?: string | null | undefined;
  /**
   * Unique identifier for a default private manager.
   */
  gcp?: string | null | undefined;
  /**
   * Unique identifier for a default private manager.
   */
  azure?: string | null | undefined;
  /**
   * Unique identifier for a default private manager.
   */
  kubernetes?: string | null | undefined;
  /**
   * Unique identifier for a default private manager.
   */
  machines?: string | null | undefined;
  /**
   * Unique identifier for a default private manager.
   */
  local?: string | null | undefined;
};

export const ProjectListItemResponseMethod = {
  Framework: "framework",
  RemoteOperator: "remote-operator",
} as const;
export type ProjectListItemResponseMethod = ClosedEnum<
  typeof ProjectListItemResponseMethod
>;

export type ProjectListItemResponseDeployments = {
  enabled: boolean;
  methods?: Array<ProjectListItemResponseMethod> | undefined;
};

export type ProjectListItemResponseKeys = {
  enabled: boolean;
  applicationEncryption: boolean;
};

export const ProjectListItemResponseAllowedProvider = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type ProjectListItemResponseAllowedProvider = ClosedEnum<
  typeof ProjectListItemResponseAllowedProvider
>;

export const ProjectListItemResponseClientApi = {
  OpenaiChat: "openai-chat",
  OpenaiResponses: "openai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
export type ProjectListItemResponseClientApi = ClosedEnum<
  typeof ProjectListItemResponseClientApi
>;

export type ProjectListItemResponseRequirement = {
  publicModelId: string;
  clientApis: Array<ProjectListItemResponseClientApi>;
  required: boolean;
};

export type ProjectListItemResponseModels = {
  enabled: boolean;
  allowedProviders: Array<ProjectListItemResponseAllowedProvider>;
  requirements: Array<ProjectListItemResponseRequirement>;
};

export const ProjectListItemResponseAccess = {
  ReadWrite: "read-write",
} as const;
export type ProjectListItemResponseAccess = ClosedEnum<
  typeof ProjectListItemResponseAccess
>;

export type ProjectListItemResponseBuckets = {
  enabled: boolean;
  access: ProjectListItemResponseAccess;
};

export const ProjectListItemResponseCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
} as const;
export type ProjectListItemResponseCredentialPolicy = ClosedEnum<
  typeof ProjectListItemResponseCredentialPolicy
>;

export type ProjectListItemResponseRegistry = {
  enabled: boolean;
  repositories: Array<string>;
  credentialPolicy: ProjectListItemResponseCredentialPolicy;
};

export type ProjectListItemResponseAzure = {
  catalogImage: string;
  idleSuspendSeconds: number;
};

export type ProjectListItemResponseRemoteSandbox = {
  enabled: boolean;
  baseImage?: string | undefined;
  azure?: ProjectListItemResponseAzure | undefined;
  maxLifetimeSeconds?: number | undefined;
};

export type ProjectListItemResponseCapabilities = {
  deployments?: ProjectListItemResponseDeployments | undefined;
  keys?: ProjectListItemResponseKeys | undefined;
  models?: ProjectListItemResponseModels | undefined;
  buckets?: ProjectListItemResponseBuckets | undefined;
  registry?: ProjectListItemResponseRegistry | undefined;
  remoteSandbox?: ProjectListItemResponseRemoteSandbox | undefined;
};

/**
 * Capabilities this Project may offer through setup links.
 */
export type ProjectListItemResponseProjectCapabilities = {
  schemaVersion: number;
  capabilities: ProjectListItemResponseCapabilities;
};

export type ProjectListItemResponse = {
  /**
   * Unique identifier for the project.
   */
  id: string;
  /**
   * Project name.
   */
  name: string;
  /**
   * Verified source repository connected to the project. Alien uses this for GitHub Actions setup and source-aware features; releases are still created explicitly by CI or `alien release`.
   */
  gitRepository?: ProjectListItemResponseGitRepository | null | undefined;
  /**
   * The name of a directory or relative path to the source code of your project. When null is used it will default to the project root
   */
  rootDirectory?: string | null | undefined;
  /**
   * Customer-facing deployment portal appearance settings.
   */
  deploymentPortalAppearance?:
    | ProjectListItemResponseDeploymentPortalAppearance
    | null
    | undefined;
  /**
   * Configuration for embedded packages (CLI, CloudFormation, Helm, Terraform)
   */
  packagesConfig?: ProjectListItemResponsePackagesConfig | null | undefined;
  /**
   * Selected domain for this project (null = default system domain)
   */
  domainId?: string | null | undefined;
  /**
   * Project default private managers for new push deployments.
   */
  defaultManagers?: ProjectListItemResponseDefaultManagers | null | undefined;
  /**
   * Capabilities this Project may offer through setup links.
   */
  projectCapabilities?:
    | ProjectListItemResponseProjectCapabilities
    | null
    | undefined;
  createdAt: Date;
  /**
   * Unique identifier for the workspace.
   */
  workspaceId: string;
  deploymentCount?: number | undefined;
  latestRelease?: ProjectReleaseInfo | null | undefined;
};

/** @internal */
export const ProjectListItemResponseType$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseType
> = z.enum(ProjectListItemResponseType);

/** @internal */
export const ProjectListItemResponseGitRepository$inboundSchema: z.ZodType<
  ProjectListItemResponseGitRepository,
  unknown
> = z.object({
  type: ProjectListItemResponseType$inboundSchema,
  repo: z.string(),
});

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

/** @internal */
export const ProjectListItemResponseDeploymentPortalAppearance$inboundSchema:
  z.ZodType<ProjectListItemResponseDeploymentPortalAppearance, unknown> = z
    .object({
      avatarUrl: z.nullable(z.string()).optional(),
      preset: DeploymentPortalAppearancePreset$inboundSchema.default("clean"),
      accentColor: DeploymentPortalAccentColor$inboundSchema.default("blue"),
      title: z.nullable(z.string()).optional(),
      subtitle: z.nullable(z.string()).optional(),
      supportUrl: z.nullable(z.string()).optional(),
      docsUrl: z.nullable(z.string()).optional(),
      density: DeploymentPortalDensity$inboundSchema.default("comfortable"),
    });

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

/** @internal */
export const ProjectListItemResponseBinaryTarget$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseBinaryTarget
> = z.enum(ProjectListItemResponseBinaryTarget);

/** @internal */
export const ProjectListItemResponseCli$inboundSchema: z.ZodType<
  ProjectListItemResponseCli,
  unknown
> = z.object({
  binaryTargets: z.array(ProjectListItemResponseBinaryTarget$inboundSchema)
    .optional(),
  displayName: z.string(),
  name: z.string(),
  enabled: z.boolean(),
});

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

/** @internal */
export const ProjectListItemResponseCloudformation$inboundSchema: z.ZodType<
  ProjectListItemResponseCloudformation,
  unknown
> = z.object({
  enabled: z.boolean(),
  displayName: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const ProjectListItemResponseOperatorImage$inboundSchema: z.ZodType<
  ProjectListItemResponseOperatorImage,
  unknown
> = z.object({
  brand: z.nullable(z.string()).optional(),
  displayName: z.string(),
  envPrefix: z.nullable(z.string()).optional(),
  labelDomain: z.nullable(z.string()).optional(),
  name: z.string(),
  enabled: z.boolean(),
});

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

/** @internal */
export const ProjectListItemResponseHelm$inboundSchema: z.ZodType<
  ProjectListItemResponseHelm,
  unknown
> = z.object({
  chartName: z.string(),
  description: z.string(),
  enabled: z.boolean(),
});

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

/** @internal */
export const ProjectListItemResponseTerraform$inboundSchema: z.ZodType<
  ProjectListItemResponseTerraform,
  unknown
> = z.object({
  enabled: z.boolean(),
  displayName: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const ProjectListItemResponsePackagesConfig$inboundSchema: z.ZodType<
  ProjectListItemResponsePackagesConfig,
  unknown
> = z.object({
  cli: z.nullable(z.lazy(() => ProjectListItemResponseCli$inboundSchema))
    .optional(),
  cloudformation: z.nullable(
    z.lazy(() => ProjectListItemResponseCloudformation$inboundSchema),
  ).optional(),
  operatorImage: z.nullable(
    z.lazy(() => ProjectListItemResponseOperatorImage$inboundSchema),
  ).optional(),
  helm: z.nullable(z.lazy(() => ProjectListItemResponseHelm$inboundSchema))
    .optional(),
  terraform: z.nullable(
    z.lazy(() => ProjectListItemResponseTerraform$inboundSchema),
  ).optional(),
});

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

/** @internal */
export const ProjectListItemResponseDefaultManagers$inboundSchema: z.ZodType<
  ProjectListItemResponseDefaultManagers,
  unknown
> = z.object({
  aws: z.nullable(z.string()).optional(),
  gcp: z.nullable(z.string()).optional(),
  azure: z.nullable(z.string()).optional(),
  kubernetes: z.nullable(z.string()).optional(),
  machines: z.nullable(z.string()).optional(),
  local: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const ProjectListItemResponseMethod$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseMethod
> = z.enum(ProjectListItemResponseMethod);

/** @internal */
export const ProjectListItemResponseDeployments$inboundSchema: z.ZodType<
  ProjectListItemResponseDeployments,
  unknown
> = z.object({
  enabled: z.boolean(),
  methods: z.array(ProjectListItemResponseMethod$inboundSchema).optional(),
});

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

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

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

/** @internal */
export const ProjectListItemResponseAllowedProvider$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseAllowedProvider
> = z.enum(ProjectListItemResponseAllowedProvider);

/** @internal */
export const ProjectListItemResponseClientApi$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseClientApi
> = z.enum(ProjectListItemResponseClientApi);

/** @internal */
export const ProjectListItemResponseRequirement$inboundSchema: z.ZodType<
  ProjectListItemResponseRequirement,
  unknown
> = z.object({
  publicModelId: z.string(),
  clientApis: z.array(ProjectListItemResponseClientApi$inboundSchema),
  required: z.boolean(),
});

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

/** @internal */
export const ProjectListItemResponseModels$inboundSchema: z.ZodType<
  ProjectListItemResponseModels,
  unknown
> = z.object({
  enabled: z.boolean(),
  allowedProviders: z.array(
    ProjectListItemResponseAllowedProvider$inboundSchema,
  ),
  requirements: z.array(
    z.lazy(() => ProjectListItemResponseRequirement$inboundSchema),
  ),
});

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

/** @internal */
export const ProjectListItemResponseAccess$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseAccess
> = z.enum(ProjectListItemResponseAccess);

/** @internal */
export const ProjectListItemResponseBuckets$inboundSchema: z.ZodType<
  ProjectListItemResponseBuckets,
  unknown
> = z.object({
  enabled: z.boolean(),
  access: ProjectListItemResponseAccess$inboundSchema,
});

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

/** @internal */
export const ProjectListItemResponseCredentialPolicy$inboundSchema: z.ZodEnum<
  typeof ProjectListItemResponseCredentialPolicy
> = z.enum(ProjectListItemResponseCredentialPolicy);

/** @internal */
export const ProjectListItemResponseRegistry$inboundSchema: z.ZodType<
  ProjectListItemResponseRegistry,
  unknown
> = z.object({
  enabled: z.boolean(),
  repositories: z.array(z.string()),
  credentialPolicy: ProjectListItemResponseCredentialPolicy$inboundSchema,
});

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

/** @internal */
export const ProjectListItemResponseAzure$inboundSchema: z.ZodType<
  ProjectListItemResponseAzure,
  unknown
> = z.object({
  catalogImage: z.string(),
  idleSuspendSeconds: z.int(),
});

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

/** @internal */
export const ProjectListItemResponseRemoteSandbox$inboundSchema: z.ZodType<
  ProjectListItemResponseRemoteSandbox,
  unknown
> = z.object({
  enabled: z.boolean(),
  baseImage: z.string().optional(),
  azure: z.lazy(() => ProjectListItemResponseAzure$inboundSchema).optional(),
  maxLifetimeSeconds: z.int().optional(),
});

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

/** @internal */
export const ProjectListItemResponseCapabilities$inboundSchema: z.ZodType<
  ProjectListItemResponseCapabilities,
  unknown
> = z.object({
  deployments: z.lazy(() => ProjectListItemResponseDeployments$inboundSchema)
    .optional(),
  keys: z.lazy(() => ProjectListItemResponseKeys$inboundSchema).optional(),
  models: z.lazy(() => ProjectListItemResponseModels$inboundSchema).optional(),
  buckets: z.lazy(() => ProjectListItemResponseBuckets$inboundSchema)
    .optional(),
  registry: z.lazy(() => ProjectListItemResponseRegistry$inboundSchema)
    .optional(),
  remoteSandbox: z.lazy(() =>
    ProjectListItemResponseRemoteSandbox$inboundSchema
  ).optional(),
});

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

/** @internal */
export const ProjectListItemResponseProjectCapabilities$inboundSchema:
  z.ZodType<ProjectListItemResponseProjectCapabilities, unknown> = z.object({
    schemaVersion: z.number(),
    capabilities: z.lazy(() =>
      ProjectListItemResponseCapabilities$inboundSchema
    ),
  });

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

/** @internal */
export const ProjectListItemResponse$inboundSchema: z.ZodType<
  ProjectListItemResponse,
  unknown
> = z.object({
  id: z.string(),
  name: z.string(),
  gitRepository: z.nullable(
    z.lazy(() => ProjectListItemResponseGitRepository$inboundSchema),
  ).optional(),
  rootDirectory: z.nullable(z.string()).optional(),
  deploymentPortalAppearance: z.nullable(
    z.lazy(() =>
      ProjectListItemResponseDeploymentPortalAppearance$inboundSchema
    ),
  ).optional(),
  packagesConfig: z.nullable(
    z.lazy(() => ProjectListItemResponsePackagesConfig$inboundSchema),
  ).optional(),
  domainId: z.nullable(z.string()).optional(),
  defaultManagers: z.nullable(
    z.lazy(() => ProjectListItemResponseDefaultManagers$inboundSchema),
  ).optional(),
  projectCapabilities: z.nullable(
    z.lazy(() => ProjectListItemResponseProjectCapabilities$inboundSchema),
  ).optional(),
  createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  workspaceId: z.string(),
  deploymentCount: z.number().optional(),
  latestRelease: z.nullable(ProjectReleaseInfo$inboundSchema).optional(),
});

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