/** The available API versions. */
export declare enum KnownVersions {
    /** The 2026-02-01-preview API version. */
    V2026_02_01_Preview = "2026-02-01-preview"
}
/** The error detail. */
export interface ErrorDetail {
    /** The error code. */
    readonly code?: string;
    /** The error message. */
    readonly message?: string;
    /** The error target. */
    readonly target?: string;
    /** The error details. */
    readonly details?: ErrorDetail[];
}
/** The error response. */
export interface ErrorResponse {
    /** The error object. */
    error?: ErrorDetail;
}
export declare function errorDetailDeserializer(item: any): ErrorDetail;
/** Deserializer for the default error response body. */
export declare function defaultErrorResponseDeserializer(item: any): ErrorResponse;
/** Auto-suspend configuration for a sandbox. */
export interface AutoSuspendPolicy {
    enabled: boolean;
    /** Idle interval, in seconds, before the sandbox is suspended. */
    interval?: number;
    mode?: "Memory" | "Disk";
}
/** Auto-delete configuration for a sandbox. */
export interface AutoDeletePolicy {
    enabled: boolean;
    /** Interval, in seconds, before an idle sandbox is deleted. */
    deleteIntervalSeconds?: number;
}
/** Lifecycle policy for a sandbox — used for both input and output. */
export interface LifecyclePolicy {
    autoSuspend?: AutoSuspendPolicy;
    autoDelete?: AutoDeletePolicy;
}
export declare function autoSuspendPolicySerializer(item: AutoSuspendPolicy): any;
export declare function autoSuspendPolicyDeserializer(item: any): AutoSuspendPolicy;
export declare function autoDeletePolicySerializer(item: AutoDeletePolicy): any;
export declare function autoDeletePolicyDeserializer(item: any): AutoDeletePolicy;
export declare function lifecyclePolicySerializer(item: LifecyclePolicy): any;
export declare function lifecyclePolicyDeserializer(item: any): LifecyclePolicy | undefined;
/** Reference to a sandbox secret to source a header value from. */
export interface EgressSecretRef {
    secretId: string;
    secretKey?: string;
    format?: string;
}
/** Reference to a managed identity to source a header value (token) from. */
export interface EgressManagedIdentityRef {
    type: "SystemAssigned" | "UserAssigned";
    resource: string;
    identityResourceId?: string;
    format?: string;
}
/** Indirect header value — exactly one of `secretRef` / `managedIdentityRef`. */
export interface EgressHeaderValueRef {
    secretRef?: EgressSecretRef;
    managedIdentityRef?: EgressManagedIdentityRef;
}
/** Header transform for an egress rule action. */
export interface EgressHeader {
    operation: "Set" | "Insert" | "Remove";
    name: string;
    value?: string;
    valueRef?: EgressHeaderValueRef;
}
/** Match conditions for an egress rule. */
export interface EgressRuleMatch {
    host: string;
    path?: string;
    methods?: string[];
}
/** Action for an egress rule (Allow/Deny/Transform/Rewrite). */
export interface EgressRuleAction {
    type: "Allow" | "Deny" | "Transform" | "Rewrite";
    host?: string;
    path?: string;
    scheme?: string;
    headers?: EgressHeader[];
}
/** Advanced egress rule with match conditions and action. */
export interface EgressRule {
    name?: string;
    match?: EgressRuleMatch;
    action?: EgressRuleAction;
}
/** Simple host-pattern egress rule. */
export interface EgressHostRule {
    pattern: string;
    action: "Allow" | "Deny";
}
/** Egress policy for a sandbox — used for both input and output. */
export interface EgressPolicy {
    defaultAction: "Allow" | "Deny";
    hostRules: EgressHostRule[];
    rules: EgressRule[];
    trafficInspection?: "Legacy" | "Full" | "Partial" | "None";
}
/** A single egress decision audit entry. */
export interface EgressDecisionEntry {
    timestamp?: string;
    host?: string;
    method?: string;
    path?: string;
    scheme?: string;
}
/** Egress decisions grouped by allowed/denied. */
export interface NetworkEgressDecisions {
    allowed: EgressDecisionEntry[];
    denied: EgressDecisionEntry[];
}
/** Egress decision audit log for a sandbox. */
export interface EgressDecisions {
    networkEgress?: NetworkEgressDecisions;
    lastUpdated?: string;
}
export declare function egressSecretRefSerializer(item: EgressSecretRef): any;
export declare function egressManagedIdentityRefSerializer(item: EgressManagedIdentityRef): any;
export declare function egressHeaderValueRefSerializer(item: EgressHeaderValueRef): any;
export declare function egressHeaderSerializer(item: EgressHeader): any;
export declare function egressRuleMatchSerializer(item: EgressRuleMatch): any;
export declare function egressRuleActionSerializer(item: EgressRuleAction): any;
export declare function egressRuleSerializer(item: EgressRule): any;
export declare function egressHostRuleSerializer(item: EgressHostRule): any;
export declare function egressPolicySerializer(item: EgressPolicy): any;
export declare function egressSecretRefDeserializer(item: any): EgressSecretRef | undefined;
export declare function egressManagedIdentityRefDeserializer(item: any): EgressManagedIdentityRef | undefined;
export declare function egressHeaderValueRefDeserializer(item: any): EgressHeaderValueRef | undefined;
export declare function egressHeaderDeserializer(item: any): EgressHeader;
export declare function egressRuleMatchDeserializer(item: any): EgressRuleMatch | undefined;
export declare function egressRuleActionDeserializer(item: any): EgressRuleAction | undefined;
export declare function egressRuleDeserializer(item: any): EgressRule;
export declare function egressHostRuleDeserializer(item: any): EgressHostRule;
export declare function egressPolicyDeserializer(item: any): EgressPolicy | undefined;
export declare function egressDecisionEntryDeserializer(item: any): EgressDecisionEntry;
export declare function networkEgressDecisionsDeserializer(item: any): NetworkEgressDecisions | undefined;
export declare function egressDecisionsDeserializer(item: any): EgressDecisions;
/** A single source-IP allow/deny rule for a sandbox port. */
export interface PortIpAccessControlRule {
    name: string;
    action: "Allow" | "Deny";
    priority: number;
    sourceCidrs: string[];
}
/** Inbound IP access control for a sandbox port. */
export interface PortIpAccessControl {
    defaultAction: "Allow" | "Deny";
    rules: PortIpAccessControlRule[];
}
/** Entra ID authentication config for a port. */
export interface PortAuthEntraId {
    enabled: boolean;
    emails: string[];
}
/** Authentication configuration for a sandbox port. */
export interface PortAuthConfig {
    anonymous?: boolean;
    entraId?: PortAuthEntraId;
}
/** A port exposed by a sandbox (response model). */
export interface SandboxPort {
    port: number;
    hostPort?: number;
    protocol?: "Http" | "Http2";
    url?: string;
    auth?: PortAuthConfig;
    ipAccessControl?: PortIpAccessControl;
}
/** Port specification for creating or updating ports (input model). */
export interface AddPortRequest {
    port: number;
    auth?: PortAuthConfig;
    protocol?: "Http" | "Http2";
    activationMode?: "Manual" | "OnDemand";
    ipAccessControl?: PortIpAccessControl;
}
export declare function portIpAccessControlRuleSerializer(item: PortIpAccessControlRule): any;
export declare function portIpAccessControlSerializer(item: PortIpAccessControl): any;
export declare function portAuthEntraIdSerializer(item: PortAuthEntraId): any;
export declare function portAuthConfigSerializer(item: PortAuthConfig): any;
export declare function addPortRequestSerializer(item: AddPortRequest): any;
export declare function portIpAccessControlRuleDeserializer(item: any): PortIpAccessControlRule;
export declare function portIpAccessControlDeserializer(item: any): PortIpAccessControl | undefined;
export declare function portAuthEntraIdDeserializer(item: any): PortAuthEntraId | undefined;
export declare function portAuthConfigDeserializer(item: any): PortAuthConfig | undefined;
export declare function sandboxPortDeserializer(item: any): SandboxPort;
export declare function sandboxPortArrayDeserializer(result: any[]): SandboxPort[];
/** Result of executing a command in a sandbox. */
export interface ExecResult {
    exitCode: number;
    stdout: string;
    stderr: string;
}
/** Request to execute a shell command. */
export interface ExecRequest {
    command: string;
    workingDirectory?: string;
}
export declare function execRequestSerializer(item: ExecRequest): any;
export declare function execResultDeserializer(item: any): ExecResult;
/** Information about a file or directory. */
export interface FileInfo {
    name: string;
    path: string;
    size?: number;
    isDirectory: boolean;
    modifiedAt?: string;
    mode?: string;
}
/** Directory listing result. */
export interface DirListing {
    path: string;
    entries: FileInfo[];
}
export declare function fileInfoDeserializer(item: any): FileInfo;
export declare function dirListingDeserializer(item: any): DirListing;
/** Status of a disk image. */
export interface DiskImageStatus {
    state: string;
    message?: string;
}
/** Container image specification for a disk image. */
export interface DiskImageSpec {
    base: string;
    entrypoint?: string[];
    cmd?: string[];
}
/** A disk image resource. */
export interface DiskImage {
    id: string;
    labels: Record<string, string>;
    image?: DiskImageSpec;
    status?: DiskImageStatus;
    name?: string;
    dockerfileContent?: string;
}
/** A public disk image. */
export interface PublicDiskImage {
    name: string;
    status?: DiskImageStatus;
    id: string;
    description?: string;
    tags: Record<string, string>;
}
/** Registry credentials for pulling private container images (input model). */
export interface RegistryCredentials {
    username: string;
    token: string;
}
/** Request to create a disk image. */
export interface CreateDiskImageRequest {
    image: DiskImageSpec;
    labels?: Record<string, string>;
    registryCredentials?: RegistryCredentials;
    managedIdentityResourceId?: string;
}
export declare function registryCredentialsSerializer(item: RegistryCredentials): any;
export declare function diskImageSpecSerializer(item: DiskImageSpec): any;
export declare function createDiskImageRequestSerializer(item: CreateDiskImageRequest): any;
export declare function diskImageStatusDeserializer(item: any): DiskImageStatus | undefined;
export declare function diskImageSpecDeserializer(item: any): DiskImageSpec | undefined;
export declare function diskImageDeserializer(item: any): DiskImage;
export declare function publicDiskImageDeserializer(item: any): PublicDiskImage;
/** The result of a paged disk-image list. */
export interface _DiskImageListResult {
    value: DiskImage[];
    nextLink?: string;
}
export declare function _diskImageListResultDeserializer(item: any): _DiskImageListResult;
/** The result of a paged public disk-image list. */
export interface _PublicDiskImageListResult {
    value: PublicDiskImage[];
    nextLink?: string;
}
export declare function _publicDiskImageListResultDeserializer(item: any): _PublicDiskImageListResult;
/** GPU configuration captured in a snapshot. */
export interface SnapshotGpu {
    sku: string;
    quantity: number;
}
/** Resource allocation captured in a snapshot. */
export interface SnapshotResources {
    cpu: string;
    memory: string;
    disk?: string;
    gpu?: SnapshotGpu;
}
/** A sandbox snapshot. */
export interface Snapshot {
    id: string;
    labels: Record<string, string>;
    sandboxId?: string;
    status?: string;
    vmmType?: string;
    createdAtUtc?: string;
    resources?: SnapshotResources;
}
export declare function snapshotGpuDeserializer(item: any): SnapshotGpu | undefined;
export declare function snapshotResourcesDeserializer(item: any): SnapshotResources | undefined;
export declare function snapshotDeserializer(item: any): Snapshot;
/** The result of a paged snapshot list. */
export interface _SnapshotListResult {
    value: Snapshot[];
    nextLink?: string;
}
export declare function _snapshotListResultDeserializer(item: any): _SnapshotListResult;
/** Selects a managed identity on the sandbox group for BYO volume auth. */
export interface SandboxGroupIdentitySelector {
    kind: "SystemAssigned" | "UserAssigned";
    resourceId?: string;
}
/** Managed-identity auth for a bring-your-own (BYO) Azure Blob volume. */
export interface AzureBlobByoManagedIdentityAuth {
    identity: SandboxGroupIdentitySelector;
}
/** Volume usage information. */
export interface VolumeUsage {
    used?: string;
    available?: string;
}
/** A volume resource. */
export interface Volume {
    name: string;
    type?: string;
    labels: Record<string, string>;
    size?: string;
    usage?: VolumeUsage;
    isAttached?: boolean;
    storageContainerResourceId?: string;
    auth?: AzureBlobByoManagedIdentityAuth;
}
/** Volume reference for sandbox creation (input model). */
export interface SandboxVolume {
    volumeName: string;
    mountpoint: string;
    readOnly?: boolean;
}
/** Volume mount request for attaching a volume to a running sandbox. */
export interface AddVolumeMountRequest {
    volumeName: string;
    mountpoint: string;
}
/** Request to create a volume. */
export interface CreateVolumeRequest {
    type: "AzureBlob" | "DataDisk" | "AzureBlobByo";
    size?: string;
    labels?: Record<string, string>;
    storageContainerResourceId?: string;
    auth?: AzureBlobByoManagedIdentityAuth;
}
export declare function sandboxGroupIdentitySelectorSerializer(item: SandboxGroupIdentitySelector): any;
export declare function sandboxGroupIdentitySelectorDeserializer(item: any): SandboxGroupIdentitySelector | undefined;
export declare function azureBlobByoManagedIdentityAuthSerializer(item: AzureBlobByoManagedIdentityAuth): any;
export declare function azureBlobByoManagedIdentityAuthDeserializer(item: any): AzureBlobByoManagedIdentityAuth | undefined;
export declare function volumeUsageDeserializer(item: any): VolumeUsage | undefined;
export declare function volumeDeserializer(item: any): Volume;
export declare function sandboxVolumeSerializer(item: SandboxVolume): any;
export declare function addVolumeMountRequestSerializer(item: AddVolumeMountRequest): any;
export declare function createVolumeRequestSerializer(item: CreateVolumeRequest): any;
/** The result of a paged volume list. */
export interface _VolumeListResult {
    value: Volume[];
    nextLink?: string;
}
export declare function _volumeListResultDeserializer(item: any): _VolumeListResult;
/** Memory or storage usage. */
export interface ResourceUsage {
    usedBytes?: number;
    totalBytes?: number;
    availableBytes?: number;
}
/** CPU usage stats. */
export interface CpuUsage {
    usageNanoCores?: number;
    usageCoreNanoSeconds?: number;
}
/** Network usage stats. */
export interface NetworkUsage {
    rxBytes?: number;
    txBytes?: number;
}
/** Resource usage statistics for a sandbox. */
export interface SandboxStats {
    cpu?: CpuUsage;
    memory?: ResourceUsage;
    storage?: ResourceUsage;
    network?: NetworkUsage;
}
export declare function resourceUsageDeserializer(item: any): ResourceUsage | undefined;
export declare function cpuUsageDeserializer(item: any): CpuUsage | undefined;
export declare function networkUsageDeserializer(item: any): NetworkUsage | undefined;
export declare function sandboxStatsDeserializer(item: any): SandboxStats;
/** Metadata about a secret. */
export interface SecretMetadata {
    id: string;
    keys: string[];
    createdAt?: string;
    updatedAt?: string;
}
/** Returned values from creating/updating or peeking a secret. */
export interface SecretValuePeek {
    id: string;
    values: Record<string, string>;
}
export declare function secretMetadataDeserializer(item: any): SecretMetadata;
export declare function secretValuePeekDeserializer(item: any): SecretValuePeek;
/** CPU, memory, and disk allocation for a sandbox. */
export interface SandboxResources {
    cpu: string;
    memory: string;
    disk: string;
}
/** Reference to a disk image used to create a sandbox. */
export interface DiskImageRef {
    name?: string;
    id?: string;
    isPublic?: boolean;
}
/** Reference to a snapshot used to create a sandbox. */
export interface SnapshotRef {
    id: string;
}
/** Source reference for sandbox creation (disk image or snapshot). */
export interface SandboxSourcesRef {
    diskImage?: DiskImageRef;
    snapshot?: SnapshotRef;
}
/** Lifecycle state of a sandbox. */
export type SandboxState = "Running" | "Stopped" | "Suspended" | "Idle" | "Resuming" | "Stopping" | "Creating" | "Deleting" | string;
/** A sandbox instance returned by get/create operations. */
export interface Sandbox {
    id: string;
    state?: SandboxState;
    labels: Record<string, string>;
    vmmType?: string;
    ports: SandboxPort[];
    resources?: SandboxResources;
    egressPolicy?: EgressPolicy;
    environment: Record<string, string>;
    connections: string[];
    customerVnetConnectionName?: string;
    sandboxGroupId?: string;
    lifecycle?: LifecyclePolicy;
    sourcesRef?: SandboxSourcesRef;
    presetSandboxType?: string;
    hostname?: string;
    createdAt?: string;
    region?: string;
    entrypoint?: string[];
    managementUrl?: string;
}
/** Request body for creating a sandbox. */
export interface CreateSandboxRequest {
    sourcesRef?: SandboxSourcesRef;
    presetSandboxType?: string;
    resources?: SandboxResources;
    lifecycle?: LifecyclePolicy;
    labels?: Record<string, string>;
    environment?: Record<string, string>;
    connections?: string[];
    egressPolicy?: EgressPolicy;
    volumes?: SandboxVolume[];
    ports?: AddPortRequest[];
    entrypoint?: string[];
    cmd?: string[];
    skipEgressProxy?: boolean;
    customerVnetConnectionName?: string;
    vmmType?: string;
}
export declare function sandboxResourcesSerializer(item: SandboxResources): any;
export declare function sandboxResourcesDeserializer(item: any): SandboxResources | undefined;
export declare function diskImageRefSerializer(item: DiskImageRef): any;
export declare function diskImageRefDeserializer(item: any): DiskImageRef | undefined;
export declare function snapshotRefDeserializer(item: any): SnapshotRef | undefined;
export declare function sandboxSourcesRefSerializer(item: SandboxSourcesRef): any;
export declare function sandboxSourcesRefDeserializer(item: any): SandboxSourcesRef | undefined;
export declare function createSandboxRequestSerializer(item: CreateSandboxRequest): any;
export declare function sandboxDeserializer(item: any): Sandbox;
/** The result of a paged sandbox list. */
export interface _SandboxListResult {
    value: Sandbox[];
    nextLink?: string;
}
export declare function _sandboxListResultDeserializer(item: any): _SandboxListResult;
/** A sandbox group resource (ARM control plane). */
export interface SandboxGroup {
    id?: string;
    name: string;
    location: string;
    tags: Record<string, string>;
    properties: Record<string, unknown>;
    identity?: Record<string, unknown>;
}
/** Request body for creating/updating a sandbox group. */
export interface SandboxGroupCreateOrUpdate {
    location: string;
    identity?: Record<string, unknown>;
    tags?: Record<string, string>;
    properties?: Record<string, unknown>;
}
export declare function sandboxGroupCreateOrUpdateSerializer(item: SandboxGroupCreateOrUpdate): any;
export declare function sandboxGroupDeserializer(item: any): SandboxGroup;
/** The result of a paged sandbox-group list. */
export interface _SandboxGroupListResult {
    value: SandboxGroup[];
    nextLink?: string;
}
export declare function _sandboxGroupListResultDeserializer(item: any): _SandboxGroupListResult;
/** The result of a paged secret list. */
export interface _SecretListResult {
    secrets: SecretMetadata[];
    nextLink?: string;
}
export declare function _secretListResultDeserializer(item: any): _SecretListResult;
//# sourceMappingURL=models.d.ts.map