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 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 declare const ModelsCapability: {
    readonly Models: "models";
    readonly Keys: "keys";
    readonly Buckets: "buckets";
    readonly Registry: "registry";
    readonly RemoteSandbox: "remoteSandbox";
};
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 declare const ModelsCredentialStatus: {
    readonly Pending: "pending";
    readonly Valid: "valid";
    readonly Invalid: "invalid";
    readonly Unknown: "unknown";
};
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 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";
    readonly RemoteSandbox: "remoteSandbox";
};
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 declare const KeysCredentialStatus: {
    readonly Pending: "pending";
    readonly Valid: "valid";
    readonly Invalid: "invalid";
    readonly Unknown: "unknown";
};
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 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";
    readonly RemoteSandbox: "remoteSandbox";
};
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 declare const BucketsCredentialStatus: {
    readonly Pending: "pending";
    readonly Valid: "valid";
    readonly Invalid: "invalid";
    readonly Unknown: "unknown";
};
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 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";
    readonly RemoteSandbox: "remoteSandbox";
};
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 declare const RegistryCredentialStatus: {
    readonly Pending: "pending";
    readonly Valid: "valid";
    readonly Invalid: "invalid";
    readonly Unknown: "unknown";
};
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 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 declare const RemoteSandboxCapability: {
    readonly Models: "models";
    readonly Keys: "keys";
    readonly Buckets: "buckets";
    readonly Registry: "registry";
    readonly RemoteSandbox: "remoteSandbox";
};
export type RemoteSandboxCapability = ClosedEnum<typeof RemoteSandboxCapability>;
export declare const RemoteSandboxState: {
    readonly NotConnected: "not-connected";
    readonly SettingUp: "setting-up";
    readonly Connected: "connected";
    readonly NeedsAttention: "needs-attention";
    readonly Revoked: "revoked";
};
export type RemoteSandboxState = ClosedEnum<typeof RemoteSandboxState>;
export declare const RemoteSandboxPlatform: {
    readonly Aws: "aws";
    readonly Gcp: "gcp";
    readonly Azure: "azure";
    readonly Local: "local";
    readonly Kubernetes: "kubernetes";
    readonly Machines: "machines";
    readonly Test: "test";
};
export type RemoteSandboxPlatform = ClosedEnum<typeof RemoteSandboxPlatform>;
export declare const RemoteSandboxHealth: {
    readonly Unknown: "unknown";
    readonly Healthy: "healthy";
    readonly Degraded: "degraded";
    readonly Unhealthy: "unhealthy";
};
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 declare const RemoteSandboxAvailability: {
    readonly Available: "available";
    readonly Blocked: "blocked";
    readonly Unknown: "unknown";
};
export type RemoteSandboxAvailability = ClosedEnum<typeof RemoteSandboxAvailability>;
export declare const RemoteSandboxAccessTest: {
    readonly Verified: "verified";
    readonly Failed: "failed";
    readonly NotChecked: "not-checked";
};
export type RemoteSandboxAccessTest = ClosedEnum<typeof RemoteSandboxAccessTest>;
export type RemoteSandboxModelCoverage = {
    publicModelId: string;
    required: boolean;
    availability: RemoteSandboxAvailability;
    blockerCodes: Array<string>;
    accessTest: RemoteSandboxAccessTest;
    accessObservedAt: Date | null;
};
export declare const RemoteSandboxProvider: {
    readonly Anthropic: "anthropic";
    readonly Databricks: "databricks";
    readonly Openai: "openai";
};
export type RemoteSandboxProvider = ClosedEnum<typeof RemoteSandboxProvider>;
export declare const RemoteSandboxCredentialStatus: {
    readonly Pending: "pending";
    readonly Valid: "valid";
    readonly Invalid: "invalid";
    readonly Unknown: "unknown";
};
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 declare const RemoteSandboxRootState: {
    readonly Pending: "pending";
    readonly Ready: "ready";
    readonly Revoked: "revoked";
};
export type RemoteSandboxRootState = ClosedEnum<typeof RemoteSandboxRootState>;
export type RemoteSandboxRoot = {
    state: RemoteSandboxRootState;
    createdAt: Date | null;
};
export declare const RemoteSandboxCredentialPolicy: {
    readonly PullOnly: "pull-only";
    readonly PushAndPull: "push-and-pull";
    readonly Mixed: "mixed";
    readonly None: "none";
};
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 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 SummaryRemoteSandbox$inboundSchema: z.ZodType<SummaryRemoteSandbox, unknown>;
export declare function summaryRemoteSandboxFromJSON(jsonString: string): SafeParseResult<SummaryRemoteSandbox, 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 ModelsCredentialStatus$inboundSchema: z.ZodEnum<typeof ModelsCredentialStatus>;
/** @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 KeysCredentialStatus$inboundSchema: z.ZodEnum<typeof KeysCredentialStatus>;
/** @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 BucketsCredentialStatus$inboundSchema: z.ZodEnum<typeof BucketsCredentialStatus>;
/** @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 RegistryCredentialStatus$inboundSchema: z.ZodEnum<typeof RegistryCredentialStatus>;
/** @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 RemoteSandboxCapability$inboundSchema: z.ZodEnum<typeof RemoteSandboxCapability>;
/** @internal */
export declare const RemoteSandboxState$inboundSchema: z.ZodEnum<typeof RemoteSandboxState>;
/** @internal */
export declare const RemoteSandboxPlatform$inboundSchema: z.ZodEnum<typeof RemoteSandboxPlatform>;
/** @internal */
export declare const RemoteSandboxHealth$inboundSchema: z.ZodEnum<typeof RemoteSandboxHealth>;
/** @internal */
export declare const RemoteSandboxObservation$inboundSchema: z.ZodType<RemoteSandboxObservation, unknown>;
export declare function remoteSandboxObservationFromJSON(jsonString: string): SafeParseResult<RemoteSandboxObservation, SDKValidationError>;
/** @internal */
export declare const RemoteSandboxAvailability$inboundSchema: z.ZodEnum<typeof RemoteSandboxAvailability>;
/** @internal */
export declare const RemoteSandboxAccessTest$inboundSchema: z.ZodEnum<typeof RemoteSandboxAccessTest>;
/** @internal */
export declare const RemoteSandboxModelCoverage$inboundSchema: z.ZodType<RemoteSandboxModelCoverage, unknown>;
export declare function remoteSandboxModelCoverageFromJSON(jsonString: string): SafeParseResult<RemoteSandboxModelCoverage, SDKValidationError>;
/** @internal */
export declare const RemoteSandboxProvider$inboundSchema: z.ZodEnum<typeof RemoteSandboxProvider>;
/** @internal */
export declare const RemoteSandboxCredentialStatus$inboundSchema: z.ZodEnum<typeof RemoteSandboxCredentialStatus>;
/** @internal */
export declare const RemoteSandboxDirectProvider$inboundSchema: z.ZodType<RemoteSandboxDirectProvider, unknown>;
export declare function remoteSandboxDirectProviderFromJSON(jsonString: string): SafeParseResult<RemoteSandboxDirectProvider, SDKValidationError>;
/** @internal */
export declare const RemoteSandboxRootState$inboundSchema: z.ZodEnum<typeof RemoteSandboxRootState>;
/** @internal */
export declare const RemoteSandboxRoot$inboundSchema: z.ZodType<RemoteSandboxRoot, unknown>;
export declare function remoteSandboxRootFromJSON(jsonString: string): SafeParseResult<RemoteSandboxRoot, SDKValidationError>;
/** @internal */
export declare const RemoteSandboxCredentialPolicy$inboundSchema: z.ZodEnum<typeof RemoteSandboxCredentialPolicy>;
/** @internal */
export declare const RemoteSandboxRegistry$inboundSchema: z.ZodType<RemoteSandboxRegistry, unknown>;
export declare function remoteSandboxRegistryFromJSON(jsonString: string): SafeParseResult<RemoteSandboxRegistry, SDKValidationError>;
/** @internal */
export declare const GroupRemoteSandbox$inboundSchema: z.ZodType<GroupRemoteSandbox, unknown>;
export declare function groupRemoteSandboxFromJSON(jsonString: string): SafeParseResult<GroupRemoteSandbox, 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