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

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 { SDKValidationError } from "./errors/sdkvalidationerror.js";

export const ConfigurationStatus = {
  Valid: "valid",
  Invalid: "invalid",
} as const;
export type ConfigurationStatus = ClosedEnum<typeof ConfigurationStatus>;

export type SummaryModels = {
  enabled: boolean;
  connected: number;
  settingUp: number;
  needsAttention: number;
  revoked: number;
  notConnected: number;
};

export type SummaryKeys = {
  enabled: boolean;
  connected: number;
  settingUp: number;
  needsAttention: number;
  revoked: number;
  notConnected: number;
};

export type SummaryBuckets = {
  enabled: boolean;
  connected: number;
  settingUp: number;
  needsAttention: number;
  revoked: number;
  notConnected: number;
};

export type SummaryRegistry = {
  enabled: boolean;
  connected: number;
  settingUp: number;
  needsAttention: number;
  revoked: number;
  notConnected: number;
};

export type SummaryRemoteSandbox = {
  enabled: boolean;
  connected: number;
  settingUp: number;
  needsAttention: number;
  revoked: number;
  notConnected: number;
};

export type SummaryCapabilities = {
  models: SummaryModels;
  keys: SummaryKeys;
  buckets: SummaryBuckets;
  registry: SummaryRegistry;
  remoteSandbox: SummaryRemoteSandbox;
};

export type ProjectCapabilityOverviewSummary = {
  groups: number;
  capabilities: SummaryCapabilities;
};

export const ModelsCapability = {
  Models: "models",
  Keys: "keys",
  Buckets: "buckets",
  Registry: "registry",
  RemoteSandbox: "remoteSandbox",
} as const;
export type ModelsCapability = ClosedEnum<typeof ModelsCapability>;

export const ModelsState = {
  NotConnected: "not-connected",
  SettingUp: "setting-up",
  Connected: "connected",
  NeedsAttention: "needs-attention",
  Revoked: "revoked",
} as const;
export type ModelsState = ClosedEnum<typeof ModelsState>;

export const ModelsPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Local: "local",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Test: "test",
} as const;
export type ModelsPlatform = ClosedEnum<typeof ModelsPlatform>;

export const ModelsHealth = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type ModelsHealth = ClosedEnum<typeof ModelsHealth>;

export type ModelsObservation = {
  provider: string | null;
  platform: ModelsPlatform | null;
  resourceId: string | null;
  location: string | null;
  account: string | null;
  observedAt: Date | null;
  stale: boolean;
  partial: boolean;
  health: ModelsHealth | null;
  lifecycle: string | null;
  message: string | null;
};

export const ModelsAvailability = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type ModelsAvailability = ClosedEnum<typeof ModelsAvailability>;

export const ModelsAccessTest = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type ModelsAccessTest = ClosedEnum<typeof ModelsAccessTest>;

export type ModelsModelCoverage = {
  publicModelId: string;
  required: boolean;
  availability: ModelsAvailability;
  blockerCodes: Array<string>;
  accessTest: ModelsAccessTest;
  accessObservedAt: Date | null;
};

export const ModelsProvider = {
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type ModelsProvider = ClosedEnum<typeof ModelsProvider>;

export const ModelsCredentialStatus = {
  Pending: "pending",
  Valid: "valid",
  Invalid: "invalid",
  Unknown: "unknown",
} as const;
export type ModelsCredentialStatus = ClosedEnum<typeof ModelsCredentialStatus>;

export type ModelsDirectProvider = {
  provider: ModelsProvider;
  providerEndpoint: string | null;
  keyFingerprint: string;
  credentialStatus: ModelsCredentialStatus;
  credentialCheckedAt: Date | null;
  catalogObservedAt: Date | null;
};

export const ModelsRootState = {
  Pending: "pending",
  Ready: "ready",
  Revoked: "revoked",
} as const;
export type ModelsRootState = ClosedEnum<typeof ModelsRootState>;

export type ModelsRoot = {
  state: ModelsRootState;
  createdAt: Date | null;
};

export const ModelsCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
  Mixed: "mixed",
  None: "none",
} as const;
export type ModelsCredentialPolicy = ClosedEnum<typeof ModelsCredentialPolicy>;

export type ModelsRegistry = {
  repositories: number;
  credentials: number;
  credentialPolicy: ModelsCredentialPolicy;
  lastVerifiedAt: Date | null;
};

export type GroupModels = {
  capability: ModelsCapability;
  enabled: boolean;
  state: ModelsState;
  /**
   * Unique identifier for the deployment.
   */
  deploymentId: string | null;
  observation: ModelsObservation | null;
  modelCoverage?: Array<ModelsModelCoverage> | undefined;
  directProvider?: ModelsDirectProvider | undefined;
  root?: ModelsRoot | undefined;
  registry?: ModelsRegistry | undefined;
};

export const KeysCapability = {
  Models: "models",
  Keys: "keys",
  Buckets: "buckets",
  Registry: "registry",
  RemoteSandbox: "remoteSandbox",
} as const;
export type KeysCapability = ClosedEnum<typeof KeysCapability>;

export const KeysState = {
  NotConnected: "not-connected",
  SettingUp: "setting-up",
  Connected: "connected",
  NeedsAttention: "needs-attention",
  Revoked: "revoked",
} as const;
export type KeysState = ClosedEnum<typeof KeysState>;

export const KeysPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Local: "local",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Test: "test",
} as const;
export type KeysPlatform = ClosedEnum<typeof KeysPlatform>;

export const KeysHealth = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type KeysHealth = ClosedEnum<typeof KeysHealth>;

export type KeysObservation = {
  provider: string | null;
  platform: KeysPlatform | null;
  resourceId: string | null;
  location: string | null;
  account: string | null;
  observedAt: Date | null;
  stale: boolean;
  partial: boolean;
  health: KeysHealth | null;
  lifecycle: string | null;
  message: string | null;
};

export const KeysAvailability = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type KeysAvailability = ClosedEnum<typeof KeysAvailability>;

export const KeysAccessTest = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type KeysAccessTest = ClosedEnum<typeof KeysAccessTest>;

export type KeysModelCoverage = {
  publicModelId: string;
  required: boolean;
  availability: KeysAvailability;
  blockerCodes: Array<string>;
  accessTest: KeysAccessTest;
  accessObservedAt: Date | null;
};

export const KeysProvider = {
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type KeysProvider = ClosedEnum<typeof KeysProvider>;

export const KeysCredentialStatus = {
  Pending: "pending",
  Valid: "valid",
  Invalid: "invalid",
  Unknown: "unknown",
} as const;
export type KeysCredentialStatus = ClosedEnum<typeof KeysCredentialStatus>;

export type KeysDirectProvider = {
  provider: KeysProvider;
  providerEndpoint: string | null;
  keyFingerprint: string;
  credentialStatus: KeysCredentialStatus;
  credentialCheckedAt: Date | null;
  catalogObservedAt: Date | null;
};

export const KeysRootState = {
  Pending: "pending",
  Ready: "ready",
  Revoked: "revoked",
} as const;
export type KeysRootState = ClosedEnum<typeof KeysRootState>;

export type KeysRoot = {
  state: KeysRootState;
  createdAt: Date | null;
};

export const KeysCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
  Mixed: "mixed",
  None: "none",
} as const;
export type KeysCredentialPolicy = ClosedEnum<typeof KeysCredentialPolicy>;

export type KeysRegistry = {
  repositories: number;
  credentials: number;
  credentialPolicy: KeysCredentialPolicy;
  lastVerifiedAt: Date | null;
};

export type GroupKeys = {
  capability: KeysCapability;
  enabled: boolean;
  state: KeysState;
  /**
   * Unique identifier for the deployment.
   */
  deploymentId: string | null;
  observation: KeysObservation | null;
  modelCoverage?: Array<KeysModelCoverage> | undefined;
  directProvider?: KeysDirectProvider | undefined;
  root?: KeysRoot | undefined;
  registry?: KeysRegistry | undefined;
};

export const BucketsCapability = {
  Models: "models",
  Keys: "keys",
  Buckets: "buckets",
  Registry: "registry",
  RemoteSandbox: "remoteSandbox",
} as const;
export type BucketsCapability = ClosedEnum<typeof BucketsCapability>;

export const BucketsState = {
  NotConnected: "not-connected",
  SettingUp: "setting-up",
  Connected: "connected",
  NeedsAttention: "needs-attention",
  Revoked: "revoked",
} as const;
export type BucketsState = ClosedEnum<typeof BucketsState>;

export const BucketsPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Local: "local",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Test: "test",
} as const;
export type BucketsPlatform = ClosedEnum<typeof BucketsPlatform>;

export const BucketsHealth = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type BucketsHealth = ClosedEnum<typeof BucketsHealth>;

export type BucketsObservation = {
  provider: string | null;
  platform: BucketsPlatform | null;
  resourceId: string | null;
  location: string | null;
  account: string | null;
  observedAt: Date | null;
  stale: boolean;
  partial: boolean;
  health: BucketsHealth | null;
  lifecycle: string | null;
  message: string | null;
};

export const BucketsAvailability = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type BucketsAvailability = ClosedEnum<typeof BucketsAvailability>;

export const BucketsAccessTest = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type BucketsAccessTest = ClosedEnum<typeof BucketsAccessTest>;

export type BucketsModelCoverage = {
  publicModelId: string;
  required: boolean;
  availability: BucketsAvailability;
  blockerCodes: Array<string>;
  accessTest: BucketsAccessTest;
  accessObservedAt: Date | null;
};

export const BucketsProvider = {
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type BucketsProvider = ClosedEnum<typeof BucketsProvider>;

export const BucketsCredentialStatus = {
  Pending: "pending",
  Valid: "valid",
  Invalid: "invalid",
  Unknown: "unknown",
} as const;
export type BucketsCredentialStatus = ClosedEnum<
  typeof BucketsCredentialStatus
>;

export type BucketsDirectProvider = {
  provider: BucketsProvider;
  providerEndpoint: string | null;
  keyFingerprint: string;
  credentialStatus: BucketsCredentialStatus;
  credentialCheckedAt: Date | null;
  catalogObservedAt: Date | null;
};

export const BucketsRootState = {
  Pending: "pending",
  Ready: "ready",
  Revoked: "revoked",
} as const;
export type BucketsRootState = ClosedEnum<typeof BucketsRootState>;

export type BucketsRoot = {
  state: BucketsRootState;
  createdAt: Date | null;
};

export const BucketsCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
  Mixed: "mixed",
  None: "none",
} as const;
export type BucketsCredentialPolicy = ClosedEnum<
  typeof BucketsCredentialPolicy
>;

export type BucketsRegistry = {
  repositories: number;
  credentials: number;
  credentialPolicy: BucketsCredentialPolicy;
  lastVerifiedAt: Date | null;
};

export type GroupBuckets = {
  capability: BucketsCapability;
  enabled: boolean;
  state: BucketsState;
  /**
   * Unique identifier for the deployment.
   */
  deploymentId: string | null;
  observation: BucketsObservation | null;
  modelCoverage?: Array<BucketsModelCoverage> | undefined;
  directProvider?: BucketsDirectProvider | undefined;
  root?: BucketsRoot | undefined;
  registry?: BucketsRegistry | undefined;
};

export const RegistryCapability = {
  Models: "models",
  Keys: "keys",
  Buckets: "buckets",
  Registry: "registry",
  RemoteSandbox: "remoteSandbox",
} as const;
export type RegistryCapability = ClosedEnum<typeof RegistryCapability>;

export const RegistryState = {
  NotConnected: "not-connected",
  SettingUp: "setting-up",
  Connected: "connected",
  NeedsAttention: "needs-attention",
  Revoked: "revoked",
} as const;
export type RegistryState = ClosedEnum<typeof RegistryState>;

export const RegistryPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Local: "local",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Test: "test",
} as const;
export type RegistryPlatform = ClosedEnum<typeof RegistryPlatform>;

export const RegistryHealth = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type RegistryHealth = ClosedEnum<typeof RegistryHealth>;

export type RegistryObservation = {
  provider: string | null;
  platform: RegistryPlatform | null;
  resourceId: string | null;
  location: string | null;
  account: string | null;
  observedAt: Date | null;
  stale: boolean;
  partial: boolean;
  health: RegistryHealth | null;
  lifecycle: string | null;
  message: string | null;
};

export const RegistryAvailability = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type RegistryAvailability = ClosedEnum<typeof RegistryAvailability>;

export const RegistryAccessTest = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type RegistryAccessTest = ClosedEnum<typeof RegistryAccessTest>;

export type RegistryModelCoverage = {
  publicModelId: string;
  required: boolean;
  availability: RegistryAvailability;
  blockerCodes: Array<string>;
  accessTest: RegistryAccessTest;
  accessObservedAt: Date | null;
};

export const RegistryProvider = {
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type RegistryProvider = ClosedEnum<typeof RegistryProvider>;

export const RegistryCredentialStatus = {
  Pending: "pending",
  Valid: "valid",
  Invalid: "invalid",
  Unknown: "unknown",
} as const;
export type RegistryCredentialStatus = ClosedEnum<
  typeof RegistryCredentialStatus
>;

export type RegistryDirectProvider = {
  provider: RegistryProvider;
  providerEndpoint: string | null;
  keyFingerprint: string;
  credentialStatus: RegistryCredentialStatus;
  credentialCheckedAt: Date | null;
  catalogObservedAt: Date | null;
};

export const RegistryRootState = {
  Pending: "pending",
  Ready: "ready",
  Revoked: "revoked",
} as const;
export type RegistryRootState = ClosedEnum<typeof RegistryRootState>;

export type RegistryRoot = {
  state: RegistryRootState;
  createdAt: Date | null;
};

export const ProjectCapabilityOverviewCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
  Mixed: "mixed",
  None: "none",
} as const;
export type ProjectCapabilityOverviewCredentialPolicy = ClosedEnum<
  typeof ProjectCapabilityOverviewCredentialPolicy
>;

export type GroupRegistryRegistry = {
  repositories: number;
  credentials: number;
  credentialPolicy: ProjectCapabilityOverviewCredentialPolicy;
  lastVerifiedAt: Date | null;
};

export type GroupRegistry = {
  capability: RegistryCapability;
  enabled: boolean;
  state: RegistryState;
  /**
   * Unique identifier for the deployment.
   */
  deploymentId: string | null;
  observation: RegistryObservation | null;
  modelCoverage?: Array<RegistryModelCoverage> | undefined;
  directProvider?: RegistryDirectProvider | undefined;
  root?: RegistryRoot | undefined;
  registry?: GroupRegistryRegistry | undefined;
};

export const RemoteSandboxCapability = {
  Models: "models",
  Keys: "keys",
  Buckets: "buckets",
  Registry: "registry",
  RemoteSandbox: "remoteSandbox",
} as const;
export type RemoteSandboxCapability = ClosedEnum<
  typeof RemoteSandboxCapability
>;

export const RemoteSandboxState = {
  NotConnected: "not-connected",
  SettingUp: "setting-up",
  Connected: "connected",
  NeedsAttention: "needs-attention",
  Revoked: "revoked",
} as const;
export type RemoteSandboxState = ClosedEnum<typeof RemoteSandboxState>;

export const RemoteSandboxPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Local: "local",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Test: "test",
} as const;
export type RemoteSandboxPlatform = ClosedEnum<typeof RemoteSandboxPlatform>;

export const RemoteSandboxHealth = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type RemoteSandboxHealth = ClosedEnum<typeof RemoteSandboxHealth>;

export type RemoteSandboxObservation = {
  provider: string | null;
  platform: RemoteSandboxPlatform | null;
  resourceId: string | null;
  location: string | null;
  account: string | null;
  observedAt: Date | null;
  stale: boolean;
  partial: boolean;
  health: RemoteSandboxHealth | null;
  lifecycle: string | null;
  message: string | null;
};

export const RemoteSandboxAvailability = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type RemoteSandboxAvailability = ClosedEnum<
  typeof RemoteSandboxAvailability
>;

export const RemoteSandboxAccessTest = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type RemoteSandboxAccessTest = ClosedEnum<
  typeof RemoteSandboxAccessTest
>;

export type RemoteSandboxModelCoverage = {
  publicModelId: string;
  required: boolean;
  availability: RemoteSandboxAvailability;
  blockerCodes: Array<string>;
  accessTest: RemoteSandboxAccessTest;
  accessObservedAt: Date | null;
};

export const RemoteSandboxProvider = {
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type RemoteSandboxProvider = ClosedEnum<typeof RemoteSandboxProvider>;

export const RemoteSandboxCredentialStatus = {
  Pending: "pending",
  Valid: "valid",
  Invalid: "invalid",
  Unknown: "unknown",
} as const;
export type RemoteSandboxCredentialStatus = ClosedEnum<
  typeof RemoteSandboxCredentialStatus
>;

export type RemoteSandboxDirectProvider = {
  provider: RemoteSandboxProvider;
  providerEndpoint: string | null;
  keyFingerprint: string;
  credentialStatus: RemoteSandboxCredentialStatus;
  credentialCheckedAt: Date | null;
  catalogObservedAt: Date | null;
};

export const RemoteSandboxRootState = {
  Pending: "pending",
  Ready: "ready",
  Revoked: "revoked",
} as const;
export type RemoteSandboxRootState = ClosedEnum<typeof RemoteSandboxRootState>;

export type RemoteSandboxRoot = {
  state: RemoteSandboxRootState;
  createdAt: Date | null;
};

export const RemoteSandboxCredentialPolicy = {
  PullOnly: "pull-only",
  PushAndPull: "push-and-pull",
  Mixed: "mixed",
  None: "none",
} as const;
export type RemoteSandboxCredentialPolicy = ClosedEnum<
  typeof RemoteSandboxCredentialPolicy
>;

export type RemoteSandboxRegistry = {
  repositories: number;
  credentials: number;
  credentialPolicy: RemoteSandboxCredentialPolicy;
  lastVerifiedAt: Date | null;
};

export type GroupRemoteSandbox = {
  capability: RemoteSandboxCapability;
  enabled: boolean;
  state: RemoteSandboxState;
  /**
   * Unique identifier for the deployment.
   */
  deploymentId: string | null;
  observation: RemoteSandboxObservation | null;
  modelCoverage?: Array<RemoteSandboxModelCoverage> | undefined;
  directProvider?: RemoteSandboxDirectProvider | undefined;
  root?: RemoteSandboxRoot | undefined;
  registry?: RemoteSandboxRegistry | undefined;
};

export type GroupCapabilities = {
  models: GroupModels;
  keys: GroupKeys;
  buckets: GroupBuckets;
  registry: GroupRegistry;
  remoteSandbox: GroupRemoteSandbox;
};

export type Group = {
  /**
   * Unique identifier for the deployment group.
   */
  deploymentGroupId: string;
  name: string;
  externalId: string | null;
  createdAt: Date;
  capabilities: GroupCapabilities;
};

export type ProjectCapabilityOverview = {
  generatedAt: Date;
  configurationStatus: ConfigurationStatus;
  summary: ProjectCapabilityOverviewSummary;
  groups: Array<Group>;
};

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

/** @internal */
export const SummaryModels$inboundSchema: z.ZodType<SummaryModels, unknown> = z
  .object({
    enabled: z.boolean(),
    connected: z.int(),
    settingUp: z.int(),
    needsAttention: z.int(),
    revoked: z.int(),
    notConnected: z.int(),
  });

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

/** @internal */
export const SummaryKeys$inboundSchema: z.ZodType<SummaryKeys, unknown> = z
  .object({
    enabled: z.boolean(),
    connected: z.int(),
    settingUp: z.int(),
    needsAttention: z.int(),
    revoked: z.int(),
    notConnected: z.int(),
  });

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

/** @internal */
export const SummaryBuckets$inboundSchema: z.ZodType<SummaryBuckets, unknown> =
  z.object({
    enabled: z.boolean(),
    connected: z.int(),
    settingUp: z.int(),
    needsAttention: z.int(),
    revoked: z.int(),
    notConnected: z.int(),
  });

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

/** @internal */
export const SummaryRegistry$inboundSchema: z.ZodType<
  SummaryRegistry,
  unknown
> = z.object({
  enabled: z.boolean(),
  connected: z.int(),
  settingUp: z.int(),
  needsAttention: z.int(),
  revoked: z.int(),
  notConnected: z.int(),
});

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

/** @internal */
export const SummaryRemoteSandbox$inboundSchema: z.ZodType<
  SummaryRemoteSandbox,
  unknown
> = z.object({
  enabled: z.boolean(),
  connected: z.int(),
  settingUp: z.int(),
  needsAttention: z.int(),
  revoked: z.int(),
  notConnected: z.int(),
});

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

/** @internal */
export const SummaryCapabilities$inboundSchema: z.ZodType<
  SummaryCapabilities,
  unknown
> = z.object({
  models: z.lazy(() => SummaryModels$inboundSchema),
  keys: z.lazy(() => SummaryKeys$inboundSchema),
  buckets: z.lazy(() => SummaryBuckets$inboundSchema),
  registry: z.lazy(() => SummaryRegistry$inboundSchema),
  remoteSandbox: z.lazy(() => SummaryRemoteSandbox$inboundSchema),
});

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

/** @internal */
export const ProjectCapabilityOverviewSummary$inboundSchema: z.ZodType<
  ProjectCapabilityOverviewSummary,
  unknown
> = z.object({
  groups: z.int(),
  capabilities: z.lazy(() => SummaryCapabilities$inboundSchema),
});

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

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

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

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

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

/** @internal */
export const ModelsObservation$inboundSchema: z.ZodType<
  ModelsObservation,
  unknown
> = z.object({
  provider: z.nullable(z.string()),
  platform: z.nullable(ModelsPlatform$inboundSchema),
  resourceId: z.nullable(z.string()),
  location: z.nullable(z.string()),
  account: z.nullable(z.string()),
  observedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  stale: z.boolean(),
  partial: z.boolean(),
  health: z.nullable(ModelsHealth$inboundSchema),
  lifecycle: z.nullable(z.string()),
  message: z.nullable(z.string()),
});

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

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

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

/** @internal */
export const ModelsModelCoverage$inboundSchema: z.ZodType<
  ModelsModelCoverage,
  unknown
> = z.object({
  publicModelId: z.string(),
  required: z.boolean(),
  availability: ModelsAvailability$inboundSchema,
  blockerCodes: z.array(z.string()),
  accessTest: ModelsAccessTest$inboundSchema,
  accessObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

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

/** @internal */
export const ModelsDirectProvider$inboundSchema: z.ZodType<
  ModelsDirectProvider,
  unknown
> = z.object({
  provider: ModelsProvider$inboundSchema,
  providerEndpoint: z.nullable(z.string()),
  keyFingerprint: z.string(),
  credentialStatus: ModelsCredentialStatus$inboundSchema,
  credentialCheckedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  catalogObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const ModelsRoot$inboundSchema: z.ZodType<ModelsRoot, unknown> = z
  .object({
    state: ModelsRootState$inboundSchema,
    createdAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ),
  });

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

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

/** @internal */
export const ModelsRegistry$inboundSchema: z.ZodType<ModelsRegistry, unknown> =
  z.object({
    repositories: z.int(),
    credentials: z.int(),
    credentialPolicy: ModelsCredentialPolicy$inboundSchema,
    lastVerifiedAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ),
  });

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

/** @internal */
export const GroupModels$inboundSchema: z.ZodType<GroupModels, unknown> = z
  .object({
    capability: ModelsCapability$inboundSchema,
    enabled: z.boolean(),
    state: ModelsState$inboundSchema,
    deploymentId: z.nullable(z.string()),
    observation: z.nullable(z.lazy(() => ModelsObservation$inboundSchema)),
    modelCoverage: z.array(z.lazy(() => ModelsModelCoverage$inboundSchema))
      .optional(),
    directProvider: z.lazy(() => ModelsDirectProvider$inboundSchema).optional(),
    root: z.lazy(() => ModelsRoot$inboundSchema).optional(),
    registry: z.lazy(() => ModelsRegistry$inboundSchema).optional(),
  });

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

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

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

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

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

/** @internal */
export const KeysObservation$inboundSchema: z.ZodType<
  KeysObservation,
  unknown
> = z.object({
  provider: z.nullable(z.string()),
  platform: z.nullable(KeysPlatform$inboundSchema),
  resourceId: z.nullable(z.string()),
  location: z.nullable(z.string()),
  account: z.nullable(z.string()),
  observedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  stale: z.boolean(),
  partial: z.boolean(),
  health: z.nullable(KeysHealth$inboundSchema),
  lifecycle: z.nullable(z.string()),
  message: z.nullable(z.string()),
});

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

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

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

/** @internal */
export const KeysModelCoverage$inboundSchema: z.ZodType<
  KeysModelCoverage,
  unknown
> = z.object({
  publicModelId: z.string(),
  required: z.boolean(),
  availability: KeysAvailability$inboundSchema,
  blockerCodes: z.array(z.string()),
  accessTest: KeysAccessTest$inboundSchema,
  accessObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

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

/** @internal */
export const KeysDirectProvider$inboundSchema: z.ZodType<
  KeysDirectProvider,
  unknown
> = z.object({
  provider: KeysProvider$inboundSchema,
  providerEndpoint: z.nullable(z.string()),
  keyFingerprint: z.string(),
  credentialStatus: KeysCredentialStatus$inboundSchema,
  credentialCheckedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  catalogObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const KeysRoot$inboundSchema: z.ZodType<KeysRoot, unknown> = z.object({
  state: KeysRootState$inboundSchema,
  createdAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const KeysRegistry$inboundSchema: z.ZodType<KeysRegistry, unknown> = z
  .object({
    repositories: z.int(),
    credentials: z.int(),
    credentialPolicy: KeysCredentialPolicy$inboundSchema,
    lastVerifiedAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ),
  });

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

/** @internal */
export const GroupKeys$inboundSchema: z.ZodType<GroupKeys, unknown> = z.object({
  capability: KeysCapability$inboundSchema,
  enabled: z.boolean(),
  state: KeysState$inboundSchema,
  deploymentId: z.nullable(z.string()),
  observation: z.nullable(z.lazy(() => KeysObservation$inboundSchema)),
  modelCoverage: z.array(z.lazy(() => KeysModelCoverage$inboundSchema))
    .optional(),
  directProvider: z.lazy(() => KeysDirectProvider$inboundSchema).optional(),
  root: z.lazy(() => KeysRoot$inboundSchema).optional(),
  registry: z.lazy(() => KeysRegistry$inboundSchema).optional(),
});

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

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

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

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

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

/** @internal */
export const BucketsObservation$inboundSchema: z.ZodType<
  BucketsObservation,
  unknown
> = z.object({
  provider: z.nullable(z.string()),
  platform: z.nullable(BucketsPlatform$inboundSchema),
  resourceId: z.nullable(z.string()),
  location: z.nullable(z.string()),
  account: z.nullable(z.string()),
  observedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  stale: z.boolean(),
  partial: z.boolean(),
  health: z.nullable(BucketsHealth$inboundSchema),
  lifecycle: z.nullable(z.string()),
  message: z.nullable(z.string()),
});

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

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

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

/** @internal */
export const BucketsModelCoverage$inboundSchema: z.ZodType<
  BucketsModelCoverage,
  unknown
> = z.object({
  publicModelId: z.string(),
  required: z.boolean(),
  availability: BucketsAvailability$inboundSchema,
  blockerCodes: z.array(z.string()),
  accessTest: BucketsAccessTest$inboundSchema,
  accessObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

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

/** @internal */
export const BucketsDirectProvider$inboundSchema: z.ZodType<
  BucketsDirectProvider,
  unknown
> = z.object({
  provider: BucketsProvider$inboundSchema,
  providerEndpoint: z.nullable(z.string()),
  keyFingerprint: z.string(),
  credentialStatus: BucketsCredentialStatus$inboundSchema,
  credentialCheckedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  catalogObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const BucketsRoot$inboundSchema: z.ZodType<BucketsRoot, unknown> = z
  .object({
    state: BucketsRootState$inboundSchema,
    createdAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ),
  });

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

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

/** @internal */
export const BucketsRegistry$inboundSchema: z.ZodType<
  BucketsRegistry,
  unknown
> = z.object({
  repositories: z.int(),
  credentials: z.int(),
  credentialPolicy: BucketsCredentialPolicy$inboundSchema,
  lastVerifiedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

/** @internal */
export const GroupBuckets$inboundSchema: z.ZodType<GroupBuckets, unknown> = z
  .object({
    capability: BucketsCapability$inboundSchema,
    enabled: z.boolean(),
    state: BucketsState$inboundSchema,
    deploymentId: z.nullable(z.string()),
    observation: z.nullable(z.lazy(() => BucketsObservation$inboundSchema)),
    modelCoverage: z.array(z.lazy(() => BucketsModelCoverage$inboundSchema))
      .optional(),
    directProvider: z.lazy(() => BucketsDirectProvider$inboundSchema)
      .optional(),
    root: z.lazy(() => BucketsRoot$inboundSchema).optional(),
    registry: z.lazy(() => BucketsRegistry$inboundSchema).optional(),
  });

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

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

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

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

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

/** @internal */
export const RegistryObservation$inboundSchema: z.ZodType<
  RegistryObservation,
  unknown
> = z.object({
  provider: z.nullable(z.string()),
  platform: z.nullable(RegistryPlatform$inboundSchema),
  resourceId: z.nullable(z.string()),
  location: z.nullable(z.string()),
  account: z.nullable(z.string()),
  observedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  stale: z.boolean(),
  partial: z.boolean(),
  health: z.nullable(RegistryHealth$inboundSchema),
  lifecycle: z.nullable(z.string()),
  message: z.nullable(z.string()),
});

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

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

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

/** @internal */
export const RegistryModelCoverage$inboundSchema: z.ZodType<
  RegistryModelCoverage,
  unknown
> = z.object({
  publicModelId: z.string(),
  required: z.boolean(),
  availability: RegistryAvailability$inboundSchema,
  blockerCodes: z.array(z.string()),
  accessTest: RegistryAccessTest$inboundSchema,
  accessObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

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

/** @internal */
export const RegistryDirectProvider$inboundSchema: z.ZodType<
  RegistryDirectProvider,
  unknown
> = z.object({
  provider: RegistryProvider$inboundSchema,
  providerEndpoint: z.nullable(z.string()),
  keyFingerprint: z.string(),
  credentialStatus: RegistryCredentialStatus$inboundSchema,
  credentialCheckedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  catalogObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const RegistryRoot$inboundSchema: z.ZodType<RegistryRoot, unknown> = z
  .object({
    state: RegistryRootState$inboundSchema,
    createdAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ),
  });

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

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

/** @internal */
export const GroupRegistryRegistry$inboundSchema: z.ZodType<
  GroupRegistryRegistry,
  unknown
> = z.object({
  repositories: z.int(),
  credentials: z.int(),
  credentialPolicy: ProjectCapabilityOverviewCredentialPolicy$inboundSchema,
  lastVerifiedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

/** @internal */
export const GroupRegistry$inboundSchema: z.ZodType<GroupRegistry, unknown> = z
  .object({
    capability: RegistryCapability$inboundSchema,
    enabled: z.boolean(),
    state: RegistryState$inboundSchema,
    deploymentId: z.nullable(z.string()),
    observation: z.nullable(z.lazy(() => RegistryObservation$inboundSchema)),
    modelCoverage: z.array(z.lazy(() => RegistryModelCoverage$inboundSchema))
      .optional(),
    directProvider: z.lazy(() => RegistryDirectProvider$inboundSchema)
      .optional(),
    root: z.lazy(() => RegistryRoot$inboundSchema).optional(),
    registry: z.lazy(() => GroupRegistryRegistry$inboundSchema).optional(),
  });

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

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

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

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

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

/** @internal */
export const RemoteSandboxObservation$inboundSchema: z.ZodType<
  RemoteSandboxObservation,
  unknown
> = z.object({
  provider: z.nullable(z.string()),
  platform: z.nullable(RemoteSandboxPlatform$inboundSchema),
  resourceId: z.nullable(z.string()),
  location: z.nullable(z.string()),
  account: z.nullable(z.string()),
  observedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  stale: z.boolean(),
  partial: z.boolean(),
  health: z.nullable(RemoteSandboxHealth$inboundSchema),
  lifecycle: z.nullable(z.string()),
  message: z.nullable(z.string()),
});

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

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

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

/** @internal */
export const RemoteSandboxModelCoverage$inboundSchema: z.ZodType<
  RemoteSandboxModelCoverage,
  unknown
> = z.object({
  publicModelId: z.string(),
  required: z.boolean(),
  availability: RemoteSandboxAvailability$inboundSchema,
  blockerCodes: z.array(z.string()),
  accessTest: RemoteSandboxAccessTest$inboundSchema,
  accessObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

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

/** @internal */
export const RemoteSandboxDirectProvider$inboundSchema: z.ZodType<
  RemoteSandboxDirectProvider,
  unknown
> = z.object({
  provider: RemoteSandboxProvider$inboundSchema,
  providerEndpoint: z.nullable(z.string()),
  keyFingerprint: z.string(),
  credentialStatus: RemoteSandboxCredentialStatus$inboundSchema,
  credentialCheckedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
  catalogObservedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const RemoteSandboxRoot$inboundSchema: z.ZodType<
  RemoteSandboxRoot,
  unknown
> = z.object({
  state: RemoteSandboxRootState$inboundSchema,
  createdAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

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

/** @internal */
export const RemoteSandboxRegistry$inboundSchema: z.ZodType<
  RemoteSandboxRegistry,
  unknown
> = z.object({
  repositories: z.int(),
  credentials: z.int(),
  credentialPolicy: RemoteSandboxCredentialPolicy$inboundSchema,
  lastVerifiedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ),
});

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

/** @internal */
export const GroupRemoteSandbox$inboundSchema: z.ZodType<
  GroupRemoteSandbox,
  unknown
> = z.object({
  capability: RemoteSandboxCapability$inboundSchema,
  enabled: z.boolean(),
  state: RemoteSandboxState$inboundSchema,
  deploymentId: z.nullable(z.string()),
  observation: z.nullable(z.lazy(() => RemoteSandboxObservation$inboundSchema)),
  modelCoverage: z.array(z.lazy(() => RemoteSandboxModelCoverage$inboundSchema))
    .optional(),
  directProvider: z.lazy(() => RemoteSandboxDirectProvider$inboundSchema)
    .optional(),
  root: z.lazy(() => RemoteSandboxRoot$inboundSchema).optional(),
  registry: z.lazy(() => RemoteSandboxRegistry$inboundSchema).optional(),
});

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

/** @internal */
export const GroupCapabilities$inboundSchema: z.ZodType<
  GroupCapabilities,
  unknown
> = z.object({
  models: z.lazy(() => GroupModels$inboundSchema),
  keys: z.lazy(() => GroupKeys$inboundSchema),
  buckets: z.lazy(() => GroupBuckets$inboundSchema),
  registry: z.lazy(() => GroupRegistry$inboundSchema),
  remoteSandbox: z.lazy(() => GroupRemoteSandbox$inboundSchema),
});

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

/** @internal */
export const Group$inboundSchema: z.ZodType<Group, unknown> = z.object({
  deploymentGroupId: z.string(),
  name: z.string(),
  externalId: z.nullable(z.string()),
  createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  capabilities: z.lazy(() => GroupCapabilities$inboundSchema),
});

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

/** @internal */
export const ProjectCapabilityOverview$inboundSchema: z.ZodType<
  ProjectCapabilityOverview,
  unknown
> = z.object({
  generatedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  configurationStatus: ConfigurationStatus$inboundSchema,
  summary: z.lazy(() => ProjectCapabilityOverviewSummary$inboundSchema),
  groups: z.array(z.lazy(() => Group$inboundSchema)),
});

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