import * as z from "zod/v3";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
export type ComputeOfferCapabilities = {
    customImage: boolean;
    httpPorts: boolean;
    managedService: boolean;
    multiNode: boolean;
    persistentVolume: boolean;
    scaleToZero: boolean;
    sharedVolume: boolean;
    ssh: boolean;
    tcpPorts: boolean;
};
export type Compute = {
    accelerator: string;
    ephemeralDiskGb: number;
    gpuCount: number;
    gpuMemoryGb: number;
    instanceCount: number;
    interconnect?: string | undefined;
    memoryGb: number;
    vcpus: number;
};
export type Region = {
    country?: string | undefined;
    name: string;
};
export type ComputeOffer = {
    available: boolean;
    capabilities: ComputeOfferCapabilities;
    compute: Compute;
    expiresAt: Date | null;
    observedAt: Date;
    priceUsdHr: number;
    /**
     * Opaque compute-provider identifier. Supported values are deployment-specific.
     */
    provider: string;
    providerSku: string;
    region: Region;
};
/** @internal */
export declare const ComputeOfferCapabilities$inboundSchema: z.ZodType<ComputeOfferCapabilities, z.ZodTypeDef, unknown>;
/** @internal */
export type ComputeOfferCapabilities$Outbound = {
    custom_image: boolean;
    http_ports: boolean;
    managed_service: boolean;
    multi_node: boolean;
    persistent_volume: boolean;
    scale_to_zero: boolean;
    shared_volume: boolean;
    ssh: boolean;
    tcp_ports: boolean;
};
/** @internal */
export declare const ComputeOfferCapabilities$outboundSchema: z.ZodType<ComputeOfferCapabilities$Outbound, z.ZodTypeDef, ComputeOfferCapabilities>;
export declare function computeOfferCapabilitiesToJSON(computeOfferCapabilities: ComputeOfferCapabilities): string;
export declare function computeOfferCapabilitiesFromJSON(jsonString: string): SafeParseResult<ComputeOfferCapabilities, SDKValidationError>;
/** @internal */
export declare const Compute$inboundSchema: z.ZodType<Compute, z.ZodTypeDef, unknown>;
/** @internal */
export type Compute$Outbound = {
    accelerator: string;
    ephemeral_disk_gb: number;
    gpu_count: number;
    gpu_memory_gb: number;
    instance_count: number;
    interconnect?: string | undefined;
    memory_gb: number;
    vcpus: number;
};
/** @internal */
export declare const Compute$outboundSchema: z.ZodType<Compute$Outbound, z.ZodTypeDef, Compute>;
export declare function computeToJSON(compute: Compute): string;
export declare function computeFromJSON(jsonString: string): SafeParseResult<Compute, SDKValidationError>;
/** @internal */
export declare const Region$inboundSchema: z.ZodType<Region, z.ZodTypeDef, unknown>;
/** @internal */
export type Region$Outbound = {
    country?: string | undefined;
    name: string;
};
/** @internal */
export declare const Region$outboundSchema: z.ZodType<Region$Outbound, z.ZodTypeDef, Region>;
export declare function regionToJSON(region: Region): string;
export declare function regionFromJSON(jsonString: string): SafeParseResult<Region, SDKValidationError>;
/** @internal */
export declare const ComputeOffer$inboundSchema: z.ZodType<ComputeOffer, z.ZodTypeDef, unknown>;
/** @internal */
export type ComputeOffer$Outbound = {
    available: boolean;
    capabilities: ComputeOfferCapabilities$Outbound;
    compute: Compute$Outbound;
    expires_at: string | null;
    observed_at: string;
    price_usd_hr: number;
    provider: string;
    provider_sku: string;
    region: Region$Outbound;
};
/** @internal */
export declare const ComputeOffer$outboundSchema: z.ZodType<ComputeOffer$Outbound, z.ZodTypeDef, ComputeOffer>;
export declare function computeOfferToJSON(computeOffer: ComputeOffer): string;
export declare function computeOfferFromJSON(jsonString: string): SafeParseResult<ComputeOffer, SDKValidationError>;
//# sourceMappingURL=computeoffer.d.ts.map