@alienplatform/platform-api 3.3.12 → 3.3.13

package/src/models/projectcapabilityoverview.ts

@@ -0,0 +1,1538 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 SummaryCapabilities = {
+  models: SummaryModels;
+  keys: SummaryKeys;
+  buckets: SummaryBuckets;
+  registry: SummaryRegistry;
+};
+
+export type Summary = {
+  groups: number;
+  capabilities: SummaryCapabilities;
+};
+
+export const ModelsCapability = {
+  Models: "models",
+  Keys: "keys",
+  Buckets: "buckets",
+  Registry: "registry",
+} 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 type ModelsDirectProvider = {
+  provider: ModelsProvider;
+  providerEndpoint: string | null;
+  keyFingerprint: string;
+  availableProviderModelIds: Array<string>;
+  verifiedAt: Date;
+};
+
+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",
+} 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 type KeysDirectProvider = {
+  provider: KeysProvider;
+  providerEndpoint: string | null;
+  keyFingerprint: string;
+  availableProviderModelIds: Array<string>;
+  verifiedAt: Date;
+};
+
+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",
+} 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 type BucketsDirectProvider = {
+  provider: BucketsProvider;
+  providerEndpoint: string | null;
+  keyFingerprint: string;
+  availableProviderModelIds: Array<string>;
+  verifiedAt: Date;
+};
+
+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",
+} 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 type RegistryDirectProvider = {
+  provider: RegistryProvider;
+  providerEndpoint: string | null;
+  keyFingerprint: string;
+  availableProviderModelIds: Array<string>;
+  verifiedAt: Date;
+};
+
+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 type GroupCapabilities = {
+  models: GroupModels;
+  keys: GroupKeys;
+  buckets: GroupBuckets;
+  registry: GroupRegistry;
+};
+
+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: Summary;
+  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 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),
+});
+
+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 Summary$inboundSchema: z.ZodType<Summary, unknown> = z.object({
+  groups: z.int(),
+  capabilities: z.lazy(() => SummaryCapabilities$inboundSchema),
+});
+
+export function summaryFromJSON(
+  jsonString: string,
+): SafeParseResult<Summary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Summary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Summary' 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 ModelsDirectProvider$inboundSchema: z.ZodType<
+  ModelsDirectProvider,
+  unknown
+> = z.object({
+  provider: ModelsProvider$inboundSchema,
+  providerEndpoint: z.nullable(z.string()),
+  keyFingerprint: z.string(),
+  availableProviderModelIds: z.array(z.string()),
+  verifiedAt: 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 KeysDirectProvider$inboundSchema: z.ZodType<
+  KeysDirectProvider,
+  unknown
+> = z.object({
+  provider: KeysProvider$inboundSchema,
+  providerEndpoint: z.nullable(z.string()),
+  keyFingerprint: z.string(),
+  availableProviderModelIds: z.array(z.string()),
+  verifiedAt: 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 BucketsDirectProvider$inboundSchema: z.ZodType<
+  BucketsDirectProvider,
+  unknown
+> = z.object({
+  provider: BucketsProvider$inboundSchema,
+  providerEndpoint: z.nullable(z.string()),
+  keyFingerprint: z.string(),
+  availableProviderModelIds: z.array(z.string()),
+  verifiedAt: 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 RegistryDirectProvider$inboundSchema: z.ZodType<
+  RegistryDirectProvider,
+  unknown
+> = z.object({
+  provider: RegistryProvider$inboundSchema,
+  providerEndpoint: z.nullable(z.string()),
+  keyFingerprint: z.string(),
+  availableProviderModelIds: z.array(z.string()),
+  verifiedAt: 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 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),
+});
+
+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(() => Summary$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`,
+  );
+}