@alienplatform/platform-api 3.3.12 → 3.3.14

package/esm/models/projectcapabilityoverview.d.ts

@@ -0,0 +1,707 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ConfigurationStatus: {
+    readonly Valid: "valid";
+    readonly Invalid: "invalid";
+};
+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 ProjectCapabilityOverviewSummary = {
+    groups: number;
+    capabilities: SummaryCapabilities;
+};
+export declare const ModelsCapability: {
+    readonly Models: "models";
+    readonly Keys: "keys";
+    readonly Buckets: "buckets";
+    readonly Registry: "registry";
+};
+export type ModelsCapability = ClosedEnum<typeof ModelsCapability>;
+export declare const ModelsState: {
+    readonly NotConnected: "not-connected";
+    readonly SettingUp: "setting-up";
+    readonly Connected: "connected";
+    readonly NeedsAttention: "needs-attention";
+    readonly Revoked: "revoked";
+};
+export type ModelsState = ClosedEnum<typeof ModelsState>;
+export declare const ModelsPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Local: "local";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Test: "test";
+};
+export type ModelsPlatform = ClosedEnum<typeof ModelsPlatform>;
+export declare const ModelsHealth: {
+    readonly Unknown: "unknown";
+    readonly Healthy: "healthy";
+    readonly Degraded: "degraded";
+    readonly Unhealthy: "unhealthy";
+};
+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 declare const ModelsAvailability: {
+    readonly Available: "available";
+    readonly Blocked: "blocked";
+    readonly Unknown: "unknown";
+};
+export type ModelsAvailability = ClosedEnum<typeof ModelsAvailability>;
+export declare const ModelsAccessTest: {
+    readonly Verified: "verified";
+    readonly Failed: "failed";
+    readonly NotChecked: "not-checked";
+};
+export type ModelsAccessTest = ClosedEnum<typeof ModelsAccessTest>;
+export type ModelsModelCoverage = {
+    publicModelId: string;
+    required: boolean;
+    availability: ModelsAvailability;
+    blockerCodes: Array<string>;
+    accessTest: ModelsAccessTest;
+    accessObservedAt: Date | null;
+};
+export declare const ModelsProvider: {
+    readonly Anthropic: "anthropic";
+    readonly Databricks: "databricks";
+    readonly Openai: "openai";
+};
+export type ModelsProvider = ClosedEnum<typeof ModelsProvider>;
+export type ModelsDirectProvider = {
+    provider: ModelsProvider;
+    providerEndpoint: string | null;
+    keyFingerprint: string;
+    availableProviderModelIds: Array<string>;
+    verifiedAt: Date;
+};
+export declare const ModelsRootState: {
+    readonly Pending: "pending";
+    readonly Ready: "ready";
+    readonly Revoked: "revoked";
+};
+export type ModelsRootState = ClosedEnum<typeof ModelsRootState>;
+export type ModelsRoot = {
+    state: ModelsRootState;
+    createdAt: Date | null;
+};
+export declare const ModelsCredentialPolicy: {
+    readonly PullOnly: "pull-only";
+    readonly PushAndPull: "push-and-pull";
+    readonly Mixed: "mixed";
+    readonly None: "none";
+};
+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 declare const KeysCapability: {
+    readonly Models: "models";
+    readonly Keys: "keys";
+    readonly Buckets: "buckets";
+    readonly Registry: "registry";
+};
+export type KeysCapability = ClosedEnum<typeof KeysCapability>;
+export declare const KeysState: {
+    readonly NotConnected: "not-connected";
+    readonly SettingUp: "setting-up";
+    readonly Connected: "connected";
+    readonly NeedsAttention: "needs-attention";
+    readonly Revoked: "revoked";
+};
+export type KeysState = ClosedEnum<typeof KeysState>;
+export declare const KeysPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Local: "local";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Test: "test";
+};
+export type KeysPlatform = ClosedEnum<typeof KeysPlatform>;
+export declare const KeysHealth: {
+    readonly Unknown: "unknown";
+    readonly Healthy: "healthy";
+    readonly Degraded: "degraded";
+    readonly Unhealthy: "unhealthy";
+};
+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 declare const KeysAvailability: {
+    readonly Available: "available";
+    readonly Blocked: "blocked";
+    readonly Unknown: "unknown";
+};
+export type KeysAvailability = ClosedEnum<typeof KeysAvailability>;
+export declare const KeysAccessTest: {
+    readonly Verified: "verified";
+    readonly Failed: "failed";
+    readonly NotChecked: "not-checked";
+};
+export type KeysAccessTest = ClosedEnum<typeof KeysAccessTest>;
+export type KeysModelCoverage = {
+    publicModelId: string;
+    required: boolean;
+    availability: KeysAvailability;
+    blockerCodes: Array<string>;
+    accessTest: KeysAccessTest;
+    accessObservedAt: Date | null;
+};
+export declare const KeysProvider: {
+    readonly Anthropic: "anthropic";
+    readonly Databricks: "databricks";
+    readonly Openai: "openai";
+};
+export type KeysProvider = ClosedEnum<typeof KeysProvider>;
+export type KeysDirectProvider = {
+    provider: KeysProvider;
+    providerEndpoint: string | null;
+    keyFingerprint: string;
+    availableProviderModelIds: Array<string>;
+    verifiedAt: Date;
+};
+export declare const KeysRootState: {
+    readonly Pending: "pending";
+    readonly Ready: "ready";
+    readonly Revoked: "revoked";
+};
+export type KeysRootState = ClosedEnum<typeof KeysRootState>;
+export type KeysRoot = {
+    state: KeysRootState;
+    createdAt: Date | null;
+};
+export declare const KeysCredentialPolicy: {
+    readonly PullOnly: "pull-only";
+    readonly PushAndPull: "push-and-pull";
+    readonly Mixed: "mixed";
+    readonly None: "none";
+};
+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 declare const BucketsCapability: {
+    readonly Models: "models";
+    readonly Keys: "keys";
+    readonly Buckets: "buckets";
+    readonly Registry: "registry";
+};
+export type BucketsCapability = ClosedEnum<typeof BucketsCapability>;
+export declare const BucketsState: {
+    readonly NotConnected: "not-connected";
+    readonly SettingUp: "setting-up";
+    readonly Connected: "connected";
+    readonly NeedsAttention: "needs-attention";
+    readonly Revoked: "revoked";
+};
+export type BucketsState = ClosedEnum<typeof BucketsState>;
+export declare const BucketsPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Local: "local";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Test: "test";
+};
+export type BucketsPlatform = ClosedEnum<typeof BucketsPlatform>;
+export declare const BucketsHealth: {
+    readonly Unknown: "unknown";
+    readonly Healthy: "healthy";
+    readonly Degraded: "degraded";
+    readonly Unhealthy: "unhealthy";
+};
+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 declare const BucketsAvailability: {
+    readonly Available: "available";
+    readonly Blocked: "blocked";
+    readonly Unknown: "unknown";
+};
+export type BucketsAvailability = ClosedEnum<typeof BucketsAvailability>;
+export declare const BucketsAccessTest: {
+    readonly Verified: "verified";
+    readonly Failed: "failed";
+    readonly NotChecked: "not-checked";
+};
+export type BucketsAccessTest = ClosedEnum<typeof BucketsAccessTest>;
+export type BucketsModelCoverage = {
+    publicModelId: string;
+    required: boolean;
+    availability: BucketsAvailability;
+    blockerCodes: Array<string>;
+    accessTest: BucketsAccessTest;
+    accessObservedAt: Date | null;
+};
+export declare const BucketsProvider: {
+    readonly Anthropic: "anthropic";
+    readonly Databricks: "databricks";
+    readonly Openai: "openai";
+};
+export type BucketsProvider = ClosedEnum<typeof BucketsProvider>;
+export type BucketsDirectProvider = {
+    provider: BucketsProvider;
+    providerEndpoint: string | null;
+    keyFingerprint: string;
+    availableProviderModelIds: Array<string>;
+    verifiedAt: Date;
+};
+export declare const BucketsRootState: {
+    readonly Pending: "pending";
+    readonly Ready: "ready";
+    readonly Revoked: "revoked";
+};
+export type BucketsRootState = ClosedEnum<typeof BucketsRootState>;
+export type BucketsRoot = {
+    state: BucketsRootState;
+    createdAt: Date | null;
+};
+export declare const BucketsCredentialPolicy: {
+    readonly PullOnly: "pull-only";
+    readonly PushAndPull: "push-and-pull";
+    readonly Mixed: "mixed";
+    readonly None: "none";
+};
+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 declare const RegistryCapability: {
+    readonly Models: "models";
+    readonly Keys: "keys";
+    readonly Buckets: "buckets";
+    readonly Registry: "registry";
+};
+export type RegistryCapability = ClosedEnum<typeof RegistryCapability>;
+export declare const RegistryState: {
+    readonly NotConnected: "not-connected";
+    readonly SettingUp: "setting-up";
+    readonly Connected: "connected";
+    readonly NeedsAttention: "needs-attention";
+    readonly Revoked: "revoked";
+};
+export type RegistryState = ClosedEnum<typeof RegistryState>;
+export declare const RegistryPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Local: "local";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Test: "test";
+};
+export type RegistryPlatform = ClosedEnum<typeof RegistryPlatform>;
+export declare const RegistryHealth: {
+    readonly Unknown: "unknown";
+    readonly Healthy: "healthy";
+    readonly Degraded: "degraded";
+    readonly Unhealthy: "unhealthy";
+};
+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 declare const RegistryAvailability: {
+    readonly Available: "available";
+    readonly Blocked: "blocked";
+    readonly Unknown: "unknown";
+};
+export type RegistryAvailability = ClosedEnum<typeof RegistryAvailability>;
+export declare const RegistryAccessTest: {
+    readonly Verified: "verified";
+    readonly Failed: "failed";
+    readonly NotChecked: "not-checked";
+};
+export type RegistryAccessTest = ClosedEnum<typeof RegistryAccessTest>;
+export type RegistryModelCoverage = {
+    publicModelId: string;
+    required: boolean;
+    availability: RegistryAvailability;
+    blockerCodes: Array<string>;
+    accessTest: RegistryAccessTest;
+    accessObservedAt: Date | null;
+};
+export declare const RegistryProvider: {
+    readonly Anthropic: "anthropic";
+    readonly Databricks: "databricks";
+    readonly Openai: "openai";
+};
+export type RegistryProvider = ClosedEnum<typeof RegistryProvider>;
+export type RegistryDirectProvider = {
+    provider: RegistryProvider;
+    providerEndpoint: string | null;
+    keyFingerprint: string;
+    availableProviderModelIds: Array<string>;
+    verifiedAt: Date;
+};
+export declare const RegistryRootState: {
+    readonly Pending: "pending";
+    readonly Ready: "ready";
+    readonly Revoked: "revoked";
+};
+export type RegistryRootState = ClosedEnum<typeof RegistryRootState>;
+export type RegistryRoot = {
+    state: RegistryRootState;
+    createdAt: Date | null;
+};
+export declare const ProjectCapabilityOverviewCredentialPolicy: {
+    readonly PullOnly: "pull-only";
+    readonly PushAndPull: "push-and-pull";
+    readonly Mixed: "mixed";
+    readonly None: "none";
+};
+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: ProjectCapabilityOverviewSummary;
+    groups: Array<Group>;
+};
+/** @internal */
+export declare const ConfigurationStatus$inboundSchema: z.ZodEnum<typeof ConfigurationStatus>;
+/** @internal */
+export declare const SummaryModels$inboundSchema: z.ZodType<SummaryModels, unknown>;
+export declare function summaryModelsFromJSON(jsonString: string): SafeParseResult<SummaryModels, SDKValidationError>;
+/** @internal */
+export declare const SummaryKeys$inboundSchema: z.ZodType<SummaryKeys, unknown>;
+export declare function summaryKeysFromJSON(jsonString: string): SafeParseResult<SummaryKeys, SDKValidationError>;
+/** @internal */
+export declare const SummaryBuckets$inboundSchema: z.ZodType<SummaryBuckets, unknown>;
+export declare function summaryBucketsFromJSON(jsonString: string): SafeParseResult<SummaryBuckets, SDKValidationError>;
+/** @internal */
+export declare const SummaryRegistry$inboundSchema: z.ZodType<SummaryRegistry, unknown>;
+export declare function summaryRegistryFromJSON(jsonString: string): SafeParseResult<SummaryRegistry, SDKValidationError>;
+/** @internal */
+export declare const SummaryCapabilities$inboundSchema: z.ZodType<SummaryCapabilities, unknown>;
+export declare function summaryCapabilitiesFromJSON(jsonString: string): SafeParseResult<SummaryCapabilities, SDKValidationError>;
+/** @internal */
+export declare const ProjectCapabilityOverviewSummary$inboundSchema: z.ZodType<ProjectCapabilityOverviewSummary, unknown>;
+export declare function projectCapabilityOverviewSummaryFromJSON(jsonString: string): SafeParseResult<ProjectCapabilityOverviewSummary, SDKValidationError>;
+/** @internal */
+export declare const ModelsCapability$inboundSchema: z.ZodEnum<typeof ModelsCapability>;
+/** @internal */
+export declare const ModelsState$inboundSchema: z.ZodEnum<typeof ModelsState>;
+/** @internal */
+export declare const ModelsPlatform$inboundSchema: z.ZodEnum<typeof ModelsPlatform>;
+/** @internal */
+export declare const ModelsHealth$inboundSchema: z.ZodEnum<typeof ModelsHealth>;
+/** @internal */
+export declare const ModelsObservation$inboundSchema: z.ZodType<ModelsObservation, unknown>;
+export declare function modelsObservationFromJSON(jsonString: string): SafeParseResult<ModelsObservation, SDKValidationError>;
+/** @internal */
+export declare const ModelsAvailability$inboundSchema: z.ZodEnum<typeof ModelsAvailability>;
+/** @internal */
+export declare const ModelsAccessTest$inboundSchema: z.ZodEnum<typeof ModelsAccessTest>;
+/** @internal */
+export declare const ModelsModelCoverage$inboundSchema: z.ZodType<ModelsModelCoverage, unknown>;
+export declare function modelsModelCoverageFromJSON(jsonString: string): SafeParseResult<ModelsModelCoverage, SDKValidationError>;
+/** @internal */
+export declare const ModelsProvider$inboundSchema: z.ZodEnum<typeof ModelsProvider>;
+/** @internal */
+export declare const ModelsDirectProvider$inboundSchema: z.ZodType<ModelsDirectProvider, unknown>;
+export declare function modelsDirectProviderFromJSON(jsonString: string): SafeParseResult<ModelsDirectProvider, SDKValidationError>;
+/** @internal */
+export declare const ModelsRootState$inboundSchema: z.ZodEnum<typeof ModelsRootState>;
+/** @internal */
+export declare const ModelsRoot$inboundSchema: z.ZodType<ModelsRoot, unknown>;
+export declare function modelsRootFromJSON(jsonString: string): SafeParseResult<ModelsRoot, SDKValidationError>;
+/** @internal */
+export declare const ModelsCredentialPolicy$inboundSchema: z.ZodEnum<typeof ModelsCredentialPolicy>;
+/** @internal */
+export declare const ModelsRegistry$inboundSchema: z.ZodType<ModelsRegistry, unknown>;
+export declare function modelsRegistryFromJSON(jsonString: string): SafeParseResult<ModelsRegistry, SDKValidationError>;
+/** @internal */
+export declare const GroupModels$inboundSchema: z.ZodType<GroupModels, unknown>;
+export declare function groupModelsFromJSON(jsonString: string): SafeParseResult<GroupModels, SDKValidationError>;
+/** @internal */
+export declare const KeysCapability$inboundSchema: z.ZodEnum<typeof KeysCapability>;
+/** @internal */
+export declare const KeysState$inboundSchema: z.ZodEnum<typeof KeysState>;
+/** @internal */
+export declare const KeysPlatform$inboundSchema: z.ZodEnum<typeof KeysPlatform>;
+/** @internal */
+export declare const KeysHealth$inboundSchema: z.ZodEnum<typeof KeysHealth>;
+/** @internal */
+export declare const KeysObservation$inboundSchema: z.ZodType<KeysObservation, unknown>;
+export declare function keysObservationFromJSON(jsonString: string): SafeParseResult<KeysObservation, SDKValidationError>;
+/** @internal */
+export declare const KeysAvailability$inboundSchema: z.ZodEnum<typeof KeysAvailability>;
+/** @internal */
+export declare const KeysAccessTest$inboundSchema: z.ZodEnum<typeof KeysAccessTest>;
+/** @internal */
+export declare const KeysModelCoverage$inboundSchema: z.ZodType<KeysModelCoverage, unknown>;
+export declare function keysModelCoverageFromJSON(jsonString: string): SafeParseResult<KeysModelCoverage, SDKValidationError>;
+/** @internal */
+export declare const KeysProvider$inboundSchema: z.ZodEnum<typeof KeysProvider>;
+/** @internal */
+export declare const KeysDirectProvider$inboundSchema: z.ZodType<KeysDirectProvider, unknown>;
+export declare function keysDirectProviderFromJSON(jsonString: string): SafeParseResult<KeysDirectProvider, SDKValidationError>;
+/** @internal */
+export declare const KeysRootState$inboundSchema: z.ZodEnum<typeof KeysRootState>;
+/** @internal */
+export declare const KeysRoot$inboundSchema: z.ZodType<KeysRoot, unknown>;
+export declare function keysRootFromJSON(jsonString: string): SafeParseResult<KeysRoot, SDKValidationError>;
+/** @internal */
+export declare const KeysCredentialPolicy$inboundSchema: z.ZodEnum<typeof KeysCredentialPolicy>;
+/** @internal */
+export declare const KeysRegistry$inboundSchema: z.ZodType<KeysRegistry, unknown>;
+export declare function keysRegistryFromJSON(jsonString: string): SafeParseResult<KeysRegistry, SDKValidationError>;
+/** @internal */
+export declare const GroupKeys$inboundSchema: z.ZodType<GroupKeys, unknown>;
+export declare function groupKeysFromJSON(jsonString: string): SafeParseResult<GroupKeys, SDKValidationError>;
+/** @internal */
+export declare const BucketsCapability$inboundSchema: z.ZodEnum<typeof BucketsCapability>;
+/** @internal */
+export declare const BucketsState$inboundSchema: z.ZodEnum<typeof BucketsState>;
+/** @internal */
+export declare const BucketsPlatform$inboundSchema: z.ZodEnum<typeof BucketsPlatform>;
+/** @internal */
+export declare const BucketsHealth$inboundSchema: z.ZodEnum<typeof BucketsHealth>;
+/** @internal */
+export declare const BucketsObservation$inboundSchema: z.ZodType<BucketsObservation, unknown>;
+export declare function bucketsObservationFromJSON(jsonString: string): SafeParseResult<BucketsObservation, SDKValidationError>;
+/** @internal */
+export declare const BucketsAvailability$inboundSchema: z.ZodEnum<typeof BucketsAvailability>;
+/** @internal */
+export declare const BucketsAccessTest$inboundSchema: z.ZodEnum<typeof BucketsAccessTest>;
+/** @internal */
+export declare const BucketsModelCoverage$inboundSchema: z.ZodType<BucketsModelCoverage, unknown>;
+export declare function bucketsModelCoverageFromJSON(jsonString: string): SafeParseResult<BucketsModelCoverage, SDKValidationError>;
+/** @internal */
+export declare const BucketsProvider$inboundSchema: z.ZodEnum<typeof BucketsProvider>;
+/** @internal */
+export declare const BucketsDirectProvider$inboundSchema: z.ZodType<BucketsDirectProvider, unknown>;
+export declare function bucketsDirectProviderFromJSON(jsonString: string): SafeParseResult<BucketsDirectProvider, SDKValidationError>;
+/** @internal */
+export declare const BucketsRootState$inboundSchema: z.ZodEnum<typeof BucketsRootState>;
+/** @internal */
+export declare const BucketsRoot$inboundSchema: z.ZodType<BucketsRoot, unknown>;
+export declare function bucketsRootFromJSON(jsonString: string): SafeParseResult<BucketsRoot, SDKValidationError>;
+/** @internal */
+export declare const BucketsCredentialPolicy$inboundSchema: z.ZodEnum<typeof BucketsCredentialPolicy>;
+/** @internal */
+export declare const BucketsRegistry$inboundSchema: z.ZodType<BucketsRegistry, unknown>;
+export declare function bucketsRegistryFromJSON(jsonString: string): SafeParseResult<BucketsRegistry, SDKValidationError>;
+/** @internal */
+export declare const GroupBuckets$inboundSchema: z.ZodType<GroupBuckets, unknown>;
+export declare function groupBucketsFromJSON(jsonString: string): SafeParseResult<GroupBuckets, SDKValidationError>;
+/** @internal */
+export declare const RegistryCapability$inboundSchema: z.ZodEnum<typeof RegistryCapability>;
+/** @internal */
+export declare const RegistryState$inboundSchema: z.ZodEnum<typeof RegistryState>;
+/** @internal */
+export declare const RegistryPlatform$inboundSchema: z.ZodEnum<typeof RegistryPlatform>;
+/** @internal */
+export declare const RegistryHealth$inboundSchema: z.ZodEnum<typeof RegistryHealth>;
+/** @internal */
+export declare const RegistryObservation$inboundSchema: z.ZodType<RegistryObservation, unknown>;
+export declare function registryObservationFromJSON(jsonString: string): SafeParseResult<RegistryObservation, SDKValidationError>;
+/** @internal */
+export declare const RegistryAvailability$inboundSchema: z.ZodEnum<typeof RegistryAvailability>;
+/** @internal */
+export declare const RegistryAccessTest$inboundSchema: z.ZodEnum<typeof RegistryAccessTest>;
+/** @internal */
+export declare const RegistryModelCoverage$inboundSchema: z.ZodType<RegistryModelCoverage, unknown>;
+export declare function registryModelCoverageFromJSON(jsonString: string): SafeParseResult<RegistryModelCoverage, SDKValidationError>;
+/** @internal */
+export declare const RegistryProvider$inboundSchema: z.ZodEnum<typeof RegistryProvider>;
+/** @internal */
+export declare const RegistryDirectProvider$inboundSchema: z.ZodType<RegistryDirectProvider, unknown>;
+export declare function registryDirectProviderFromJSON(jsonString: string): SafeParseResult<RegistryDirectProvider, SDKValidationError>;
+/** @internal */
+export declare const RegistryRootState$inboundSchema: z.ZodEnum<typeof RegistryRootState>;
+/** @internal */
+export declare const RegistryRoot$inboundSchema: z.ZodType<RegistryRoot, unknown>;
+export declare function registryRootFromJSON(jsonString: string): SafeParseResult<RegistryRoot, SDKValidationError>;
+/** @internal */
+export declare const ProjectCapabilityOverviewCredentialPolicy$inboundSchema: z.ZodEnum<typeof ProjectCapabilityOverviewCredentialPolicy>;
+/** @internal */
+export declare const GroupRegistryRegistry$inboundSchema: z.ZodType<GroupRegistryRegistry, unknown>;
+export declare function groupRegistryRegistryFromJSON(jsonString: string): SafeParseResult<GroupRegistryRegistry, SDKValidationError>;
+/** @internal */
+export declare const GroupRegistry$inboundSchema: z.ZodType<GroupRegistry, unknown>;
+export declare function groupRegistryFromJSON(jsonString: string): SafeParseResult<GroupRegistry, SDKValidationError>;
+/** @internal */
+export declare const GroupCapabilities$inboundSchema: z.ZodType<GroupCapabilities, unknown>;
+export declare function groupCapabilitiesFromJSON(jsonString: string): SafeParseResult<GroupCapabilities, SDKValidationError>;
+/** @internal */
+export declare const Group$inboundSchema: z.ZodType<Group, unknown>;
+export declare function groupFromJSON(jsonString: string): SafeParseResult<Group, SDKValidationError>;
+/** @internal */
+export declare const ProjectCapabilityOverview$inboundSchema: z.ZodType<ProjectCapabilityOverview, unknown>;
+export declare function projectCapabilityOverviewFromJSON(jsonString: string): SafeParseResult<ProjectCapabilityOverview, SDKValidationError>;
+//# sourceMappingURL=projectcapabilityoverview.d.ts.map