/**
 * Edge Deployment Types
 * Type definitions for edge compute deployment
 */
/**
 * Edge deployment status
 */
export declare enum EdgeDeploymentStatus {
    PENDING = "pending",
    BUILDING = "building",
    DEPLOYING = "deploying",
    ACTIVE = "active",
    FAILED = "failed",
    UPDATING = "updating",
    INACTIVE = "inactive"
}
/**
 * Edge region
 */
export declare enum EdgeRegion {
    US_EAST = "us-east",
    US_WEST = "us-west",
    EU_WEST = "eu-west",
    EU_CENTRAL = "eu-central",
    ASIA_PACIFIC = "asia-pacific",
    ASIA_SOUTH = "asia-south",
    SOUTH_AMERICA = "south-america",
    AFRICA = "africa",
    GLOBAL = "global"
}
/**
 * Edge runtime environment
 */
export declare enum EdgeRuntime {
    CLOUDFLARE_WORKERS = "cloudflare-workers",
    VERCEL_EDGE = "vercel-edge",
    FASTLY_COMPUTE = "fastly-compute",
    AWS_LAMBDA_EDGE = "aws-lambda-edge",
    DENO_DEPLOY = "deno-deploy",
    CUSTOM = "custom"
}
/**
 * Edge optimization level
 */
export declare enum OptimizationLevel {
    NONE = "none",
    BASIC = "basic",
    ADVANCED = "advanced",
    AGGRESSIVE = "aggressive"
}
/**
 * Edge deployment configuration
 */
export interface EdgeDeploymentConfig {
    id?: string;
    name: string;
    modelId: string;
    runtime: EdgeRuntime;
    regions: EdgeRegion[];
    optimization?: OptimizationLevel;
    config?: {
        maxMemory?: number;
        maxDuration?: number;
        concurrency?: number;
        minInstances?: number;
        maxInstances?: number;
        autoScale?: boolean;
        cacheEnabled?: boolean;
        cacheTTL?: number;
        compressionEnabled?: boolean;
    };
    routing?: {
        strategy: 'nearest' | 'latency' | 'random' | 'round-robin' | 'custom';
        customLogic?: string;
        fallbackRegions?: EdgeRegion[];
        canary?: {
            enabled: boolean;
            deploymentId: string;
            trafficPercent: number;
        };
        abTest?: {
            enabled: boolean;
            testId: string;
            variants: Array<{
                id: string;
                name: string;
                weight: number;
            }>;
        };
    };
    monitoring?: {
        enabled: boolean;
        healthCheckPath?: string;
        metricsInterval?: number;
        alertThresholds?: {
            errorRate?: number;
            latency?: number;
            cpuUsage?: number;
            memoryUsage?: number;
        };
    };
    environment?: Record<string, string>;
    secrets?: Record<string, string>;
    metadata?: Record<string, unknown>;
}
/**
 * Edge deployment
 */
export interface EdgeDeployment {
    id: string;
    config: EdgeDeploymentConfig;
    status: EdgeDeploymentStatus;
    version: string;
    endpoints: Record<EdgeRegion, string>;
    createdAt: Date;
    updatedAt: Date;
    deployedAt?: Date;
    build?: {
        id: string;
        status: 'pending' | 'building' | 'success' | 'failed';
        size?: number;
        duration?: number;
        logs?: string[];
        error?: string;
    };
    metrics?: {
        totalRequests: number;
        successfulRequests: number;
        failedRequests: number;
        avgLatency: number;
        p95Latency: number;
        p99Latency: number;
        errorRate: number;
        cacheHitRate?: number;
        bytesTransferred: number;
        lastUpdated: Date;
    };
    health?: {
        status: 'healthy' | 'degraded' | 'unhealthy';
        checks: Array<{
            region: EdgeRegion;
            status: 'healthy' | 'unhealthy';
            latency: number;
            lastCheck: Date;
            error?: string;
        }>;
    };
    error?: {
        message: string;
        code?: string;
        timestamp: Date;
    };
}
/**
 * Edge build options
 */
export interface EdgeBuildOptions {
    optimize?: boolean;
    minify?: boolean;
    bundle?: boolean;
    sourceMaps?: boolean;
    target?: string;
    externals?: string[];
    plugins?: string[];
}
/**
 * Edge request routing information
 */
export interface EdgeRoutingInfo {
    requestId: string;
    clientIp?: string;
    clientRegion?: string;
    selectedRegion: EdgeRegion;
    endpoint: string;
    latency: number;
    cached: boolean;
    timestamp: Date;
}
/**
 * Edge deployment metrics
 */
export interface EdgeMetrics {
    deploymentId: string;
    period: {
        start: Date;
        end: Date;
    };
    regions: Record<EdgeRegion, {
        requests: number;
        successRate: number;
        avgLatency: number;
        p95Latency: number;
        p99Latency: number;
        errorRate: number;
        cacheHitRate?: number;
        bytesTransferred: number;
    }>;
    global: {
        totalRequests: number;
        successRate: number;
        avgLatency: number;
        p95Latency: number;
        p99Latency: number;
        errorRate: number;
        cacheHitRate?: number;
        totalBytesTransferred: number;
    };
}
/**
 * Edge deployment update
 */
export interface EdgeDeploymentUpdate {
    config?: Partial<EdgeDeploymentConfig>;
    version?: string;
    regions?: EdgeRegion[];
}
/**
 * Edge canary deployment configuration
 */
export interface CanaryDeploymentConfig {
    trafficPercent: number;
    percentage?: number;
    duration?: number;
    successCriteria?: {
        maxErrorRate?: number;
        maxLatency?: number;
        minSuccessRate?: number;
        errorRate?: number;
        minRequests?: number;
    };
    autoPromote?: boolean;
    autoRollback?: boolean;
}
/**
 * Edge A/B test configuration
 */
export interface ABTestConfig {
    name: string;
    baseDeploymentId: string;
    variants: Array<{
        id: string;
        name: string;
        modelId: string;
        weight: number;
        config?: Partial<EdgeDeploymentConfig>;
    }>;
    duration?: number;
    targetRegions?: EdgeRegion[];
    successMetric?: 'error-rate' | 'latency' | 'success-rate' | 'custom';
    successMetrics?: string[];
    autoPromote?: boolean;
}
/**
 * Edge rollback options
 */
export interface RollbackOptions {
    targetVersion: string;
    immediate?: boolean;
    regions?: EdgeRegion[];
}
//# sourceMappingURL=types.d.ts.map