export declare enum TrafficPatternType {
    OPEN_LOOP = "open-loop",
    CLOSED_LOOP = "closed-loop",
    RAMPING = "ramping",
    BURST = "burst"
}
/** Traffic pattern configuration for Client components */
export type TrafficPattern = {
    type: TrafficPatternType.OPEN_LOOP;
    meanArrivalRate: number;
    rampUpTime?: number;
} | {
    type: TrafficPatternType.CLOSED_LOOP;
    thinkTime: number;
    maxConcurrency: number;
} | {
    type: TrafficPatternType.RAMPING;
    startRate: number;
    endRate: number;
    duration: number;
} | {
    type: TrafficPatternType.BURST;
    count: number;
    atTime: number;
};
export declare enum RetryStrategyType {
    NONE = "none",
    FIXED_N = "fixed-n",
    TOKEN_BUCKET = "token-bucket",
    CIRCUIT_BREAKER = "circuit-breaker"
}
/** Retry strategy configuration for Client components */
export type RetryStrategy = {
    type: RetryStrategyType.NONE;
} | {
    type: RetryStrategyType.FIXED_N;
    maxRetries: number;
} | {
    type: RetryStrategyType.TOKEN_BUCKET;
    capacity: number;
    depositAmount: number;
} | {
    type: RetryStrategyType.CIRCUIT_BREAKER;
    windowSize: number;
    failureThreshold: number;
    maxRetries: number;
};
export declare enum DistributionType {
    UNIFORM = "uniform",
    EXPONENTIAL = "exponential",
    LOG_NORMAL = "log-normal"
}
/** Probability distribution configuration */
export type Distribution = {
    type: DistributionType.UNIFORM;
    min: number;
    max: number;
} | {
    type: DistributionType.EXPONENTIAL;
    mean: number;
} | {
    type: DistributionType.LOG_NORMAL;
    mu: number;
    sigma: number;
};
export declare enum LoadDependentLatencyMode {
    LINEAR = "linear",
    POLYNOMIAL = "polynomial",
    EXPONENTIAL = "exponential"
}
/** Load-dependent latency scaling configuration */
export type LoadDependentLatency = {
    mode: LoadDependentLatencyMode.LINEAR;
    factor: number;
} | {
    mode: LoadDependentLatencyMode.POLYNOMIAL;
    factor: number;
    exponent?: number;
} | {
    mode: LoadDependentLatencyMode.EXPONENTIAL;
    factor: number;
};
/** Client component configuration */
export interface ClientConfig {
    trafficPattern: TrafficPattern;
    retryStrategy: RetryStrategy;
    targetComponentId: string;
    timeout?: number;
    numKeys?: number;
}
/** Server component configuration */
export interface ServerConfig {
    serviceTimeDistribution: Distribution;
    concurrencyLimit: number;
    loadDependentLatency?: LoadDependentLatency;
}
/** Database component configuration */
export interface DatabaseConfig {
    readLatencyDistribution: Distribution;
    writeLatencyDistribution: Distribution;
    connectionPoolSize: number;
    loadDependentLatency?: LoadDependentLatency;
}
export declare enum CacheEvictionPolicy {
    FIFO = "fifo",
    LRU = "lru"
}
/** Cache component configuration */
export interface CacheConfig {
    hitRate: number;
    downstreamComponentId: string;
    ttl?: number;
    maxSize?: number;
    evictionPolicy?: CacheEvictionPolicy;
}
export declare enum LoadBalancerStrategy {
    ROUND_ROBIN = "round-robin",
    RANDOM = "random",
    LEAST_CONNECTIONS = "least-connections"
}
/** Load balancer component configuration */
export interface LoadBalancerConfig {
    strategy: LoadBalancerStrategy;
}
export declare enum ThrottleModeType {
    DISABLED = "disabled",
    CONCURRENCY = "concurrency",
    RPS = "rps"
}
/** Throttle mode configuration */
export type ThrottleMode = {
    type: ThrottleModeType.DISABLED;
} | {
    type: ThrottleModeType.CONCURRENCY;
    maxConcurrency: number;
} | {
    type: ThrottleModeType.RPS;
    maxRps: number;
    ewmaHalfLife: number;
};
/** Throttle component configuration */
export interface ThrottleConfig {
    mode: ThrottleMode;
}
export declare enum QueueOrdering {
    FIFO = "fifo",
    LIFO = "lifo"
}
/** Queue component configuration */
export interface QueueConfig {
    maxCapacity?: number;
    maxConcurrency?: number;
    loadSheddingThreshold?: number;
    ordering?: QueueOrdering;
}
//# sourceMappingURL=configs.d.ts.map