@nice2dev/ui-tools 1.0.10

package/dist/model-deployment.d.ts

@@ -0,0 +1,787 @@
+/**
+ * @file model-deployment.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-18.4 — Model Deployment
+ *
+ * Types for ML model deployment: REST API serving, batch inference,
+ * real-time inference, edge deployment, scaling, traffic splitting.
+ */
+/** Deployment target */
+export type DeploymentTarget = 'rest_api' | 'grpc' | 'batch' | 'streaming' | 'edge' | 'serverless' | 'embedded';
+/** Deployment status */
+export type MLDeploymentStatus = 'pending' | 'creating' | 'updating' | 'running' | 'scaling' | 'stopping' | 'stopped' | 'failed' | 'degraded';
+/** Serving runtime */
+export type ServingRuntime = 'triton' | 'tensorflow_serving' | 'torchserve' | 'onnx_runtime' | 'seldon' | 'kserve' | 'bentoml' | 'mlflow' | 'custom';
+/** Instance type */
+export type MLInstanceType = 'cpu_small' | 'cpu_medium' | 'cpu_large' | 'gpu_t4' | 'gpu_v100' | 'gpu_a100' | 'inf1' | 'inferentia' | 'custom';
+/** ML deployment config */
+export interface MLDeploymentConfig {
+    /** Theme */
+    theme?: DeploymentTheme;
+    /** Features */
+    features?: DeploymentFeatures;
+    /** Default serving config */
+    defaultServing?: ServingDefaults;
+    /** Monitoring config */
+    monitoring?: DeploymentMonitoringConfig;
+}
+/** Deployment theme */
+export interface DeploymentTheme {
+    name?: string;
+    colors?: DeploymentColors;
+}
+/** Deployment colors */
+export interface DeploymentColors {
+    running?: string;
+    stopped?: string;
+    failed?: string;
+    scaling?: string;
+}
+/** Deployment features */
+export interface DeploymentFeatures {
+    restApi?: boolean;
+    batchInference?: boolean;
+    realTimeInference?: boolean;
+    edgeDeployment?: boolean;
+    autoScaling?: boolean;
+    trafficSplitting?: boolean;
+    canaryDeployment?: boolean;
+    loadTesting?: boolean;
+}
+/** Serving defaults */
+export interface ServingDefaults {
+    runtime?: ServingRuntime;
+    instanceType?: MLInstanceType;
+    minReplicas?: number;
+    maxReplicas?: number;
+    timeout?: number;
+}
+/** Deployment monitoring config */
+export interface DeploymentMonitoringConfig {
+    enabled?: boolean;
+    metrics?: string[];
+    alerts?: DeploymentAlertConfig[];
+    logging?: DeploymentLoggingConfig;
+}
+/** Deployment alert config */
+export interface DeploymentAlertConfig {
+    metric: string;
+    condition: 'above' | 'below';
+    threshold: number;
+    duration?: number;
+    action?: string;
+}
+/** Deployment logging config */
+export interface DeploymentLoggingConfig {
+    level?: 'debug' | 'info' | 'warning' | 'error';
+    logRequests?: boolean;
+    logResponses?: boolean;
+    sampleRate?: number;
+}
+/** Model deployment */
+export interface ModelDeployment {
+    id: string;
+    name: string;
+    description?: string;
+    modelId: string;
+    modelVersion: string;
+    target: DeploymentTarget;
+    status: MLDeploymentStatus;
+    config: DeploymentConfiguration;
+    endpoint?: EndpointInfo;
+    metrics?: DeploymentMetrics;
+    replicas?: ReplicaInfo[];
+    events?: DeploymentEvent[];
+    createdAt: Date;
+    updatedAt?: Date;
+    createdBy?: string;
+}
+/** Deployment configuration */
+export interface DeploymentConfiguration {
+    runtime: ServingRuntime;
+    instanceType: MLInstanceType;
+    compute?: ComputeConfiguration;
+    serving?: ServingConfiguration;
+    scaling?: ScalingConfiguration;
+    traffic?: TrafficConfiguration;
+    security?: SecurityConfiguration;
+    observability?: ObservabilityConfiguration;
+}
+/** Compute configuration */
+export interface ComputeConfiguration {
+    cpu?: number;
+    memory?: number;
+    gpu?: number;
+    gpuType?: string;
+    accelerator?: AcceleratorConfig;
+    spot?: boolean;
+    preemptible?: boolean;
+}
+/** Accelerator config */
+export interface AcceleratorConfig {
+    type: 'nvidia-gpu' | 'google-tpu' | 'aws-inferentia' | 'custom';
+    count: number;
+    memory?: number;
+}
+/** Serving configuration */
+export interface ServingConfiguration {
+    modelPath?: string;
+    modelFormat?: string;
+    batchSize?: number;
+    maxBatchDelay?: number;
+    timeout?: number;
+    maxConcurrency?: number;
+    preprocessing?: PreprocessingConfig;
+    postprocessing?: PostprocessingConfig;
+    ensemble?: EnsembleConfig;
+}
+/** Preprocessing config */
+export interface PreprocessingConfig {
+    enabled: boolean;
+    script?: string;
+    config?: Record<string, unknown>;
+}
+/** Postprocessing config */
+export interface PostprocessingConfig {
+    enabled: boolean;
+    script?: string;
+    config?: Record<string, unknown>;
+}
+/** Ensemble config */
+export interface EnsembleConfig {
+    enabled: boolean;
+    models: EnsembleMember[];
+    strategy: 'parallel' | 'sequential' | 'voting';
+    aggregation?: 'mean' | 'max' | 'voting' | 'custom';
+}
+/** Ensemble member */
+export interface EnsembleMember {
+    name: string;
+    modelPath: string;
+    weight?: number;
+    version?: string;
+}
+/** Scaling configuration */
+export interface ScalingConfiguration {
+    minReplicas: number;
+    maxReplicas: number;
+    targetConcurrency?: number;
+    targetLatency?: number;
+    targetCpuUtilization?: number;
+    targetMemoryUtilization?: number;
+    scaleDownDelay?: number;
+    scaleUpRate?: number;
+    scaleDownRate?: number;
+}
+/** Traffic configuration */
+export interface TrafficConfiguration {
+    type: 'all' | 'canary' | 'shadow' | 'ab_test';
+    routes?: TrafficRoute[];
+    canary?: CanaryConfig;
+    shadow?: ShadowTrafficConfig;
+}
+/** Traffic route */
+export interface TrafficRoute {
+    version: string;
+    weight: number;
+    headers?: Record<string, string>;
+}
+/** Canary config */
+export interface CanaryConfig {
+    steps: CanaryStep[];
+    analysis?: CanaryAnalysis;
+    rollbackThreshold?: number;
+}
+/** Canary step */
+export interface CanaryStep {
+    weight: number;
+    duration: number;
+    metrics?: string[];
+}
+/** Canary analysis */
+export interface CanaryAnalysis {
+    metrics: CanaryMetric[];
+    interval?: number;
+    threshold?: number;
+}
+/** Canary metric */
+export interface CanaryMetric {
+    name: string;
+    threshold: number;
+    operator: 'lt' | 'gt' | 'lte' | 'gte';
+}
+/** Shadow traffic config */
+export interface ShadowTrafficConfig {
+    percentage: number;
+    targetDeployment: string;
+    compareMetrics?: string[];
+}
+/** Security configuration */
+export interface SecurityConfiguration {
+    authentication?: AuthenticationConfig;
+    authorization?: AuthorizationConfig;
+    encryption?: EncryptionConfig;
+    rateLimit?: RateLimitConfig;
+}
+/** Authentication config */
+export interface AuthenticationConfig {
+    enabled: boolean;
+    type: 'api_key' | 'jwt' | 'oauth2' | 'mtls' | 'custom';
+    config?: Record<string, unknown>;
+}
+/** Authorization config */
+export interface AuthorizationConfig {
+    enabled: boolean;
+    type: 'rbac' | 'abac' | 'custom';
+    policies?: AuthorizationPolicy[];
+}
+/** Authorization policy */
+export interface AuthorizationPolicy {
+    name: string;
+    subjects?: string[];
+    resources?: string[];
+    actions?: string[];
+    conditions?: Record<string, unknown>;
+}
+/** Encryption config */
+export interface EncryptionConfig {
+    inTransit: boolean;
+    atRest?: boolean;
+    kmsKey?: string;
+}
+/** Rate limit config */
+export interface RateLimitConfig {
+    enabled: boolean;
+    requestsPerSecond?: number;
+    requestsPerMinute?: number;
+    burstSize?: number;
+}
+/** Observability configuration */
+export interface ObservabilityConfiguration {
+    metrics?: MetricsConfig;
+    logging?: LoggingConfig;
+    tracing?: TracingConfig;
+}
+/** Metrics config */
+export interface MetricsConfig {
+    enabled: boolean;
+    exporters?: MetricsExporter[];
+    customMetrics?: CustomMetric[];
+}
+/** Metrics exporter */
+export interface MetricsExporter {
+    type: 'prometheus' | 'cloudwatch' | 'datadog' | 'custom';
+    config?: Record<string, unknown>;
+}
+/** Custom metric */
+export interface CustomMetric {
+    name: string;
+    type: 'counter' | 'gauge' | 'histogram';
+    labels?: string[];
+}
+/** Logging config */
+export interface LoggingConfig {
+    enabled: boolean;
+    level: 'debug' | 'info' | 'warning' | 'error';
+    format?: 'json' | 'text';
+    destination?: string;
+}
+/** Tracing config */
+export interface TracingConfig {
+    enabled: boolean;
+    sampleRate?: number;
+    exporter?: 'jaeger' | 'zipkin' | 'otlp' | 'xray';
+}
+/** Endpoint info */
+export interface EndpointInfo {
+    url: string;
+    protocol: 'http' | 'https' | 'grpc';
+    paths?: EndpointPath[];
+    healthCheck?: string;
+    documentation?: string;
+    schema?: EndpointSchema;
+}
+/** Endpoint path */
+export interface EndpointPath {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    description?: string;
+}
+/** Endpoint schema */
+export interface EndpointSchema {
+    input: SchemaDefinition;
+    output: SchemaDefinition;
+}
+/** Schema definition */
+export interface SchemaDefinition {
+    type: string;
+    properties?: Record<string, PropertyDefinition>;
+    required?: string[];
+    example?: unknown;
+}
+/** Property definition */
+export interface PropertyDefinition {
+    type: string;
+    description?: string;
+    format?: string;
+    items?: PropertyDefinition;
+    default?: unknown;
+}
+/** Deployment metrics */
+export interface DeploymentMetrics {
+    requests: RequestMetrics;
+    latency: LatencyMetrics;
+    throughput: ThroughputMetrics;
+    errors: ErrorMetrics;
+    resources: ResourceMetrics;
+    model?: ModelInferenceMetrics;
+}
+/** Request metrics */
+export interface RequestMetrics {
+    total: number;
+    successful: number;
+    failed: number;
+    rate: number;
+    timeline?: TimelineData;
+}
+/** Latency metrics */
+export interface LatencyMetrics {
+    mean: number;
+    p50: number;
+    p90: number;
+    p95: number;
+    p99: number;
+    max: number;
+    timeline?: TimelineData;
+}
+/** Throughput metrics */
+export interface ThroughputMetrics {
+    requestsPerSecond: number;
+    batchesPerSecond?: number;
+    samplesPerSecond?: number;
+    timeline?: TimelineData;
+}
+/** Error metrics */
+export interface ErrorMetrics {
+    rate: number;
+    byType: Record<string, number>;
+    byCode: Record<number, number>;
+    recent?: RecentError[];
+}
+/** Recent error */
+export interface RecentError {
+    timestamp: Date;
+    code: number;
+    message: string;
+    count: number;
+}
+/** Resource metrics */
+export interface ResourceMetrics {
+    cpu: UsageMetrics;
+    memory: UsageMetrics;
+    gpu?: GPUUsageMetrics;
+    network?: NetworkUsageMetrics;
+}
+/** Usage metrics */
+export interface UsageMetrics {
+    current: number;
+    average: number;
+    peak: number;
+    limit?: number;
+    timeline?: TimelineData;
+}
+/** GPU usage metrics */
+export interface GPUUsageMetrics {
+    utilization: number;
+    memory: number;
+    temperature?: number;
+    power?: number;
+}
+/** Network usage metrics */
+export interface NetworkUsageMetrics {
+    inbound: number;
+    outbound: number;
+}
+/** Model inference metrics */
+export interface ModelInferenceMetrics {
+    inferenceTime: LatencyMetrics;
+    preprocessTime?: LatencyMetrics;
+    postprocessTime?: LatencyMetrics;
+    batchSize?: DistributionMetrics;
+}
+/** Distribution metrics */
+export interface DistributionMetrics {
+    mean: number;
+    std: number;
+    min: number;
+    max: number;
+    histogram?: HistogramBin[];
+}
+/** Histogram bin */
+export interface HistogramBin {
+    low: number;
+    high: number;
+    count: number;
+}
+/** Timeline data */
+export interface TimelineData {
+    timestamps: Date[];
+    values: number[];
+}
+/** Replica info */
+export interface ReplicaInfo {
+    id: string;
+    status: ReplicaStatus;
+    host?: string;
+    port?: number;
+    metrics?: ReplicaMetrics;
+    startTime?: Date;
+    lastHeartbeat?: Date;
+}
+/** Replica status */
+export type ReplicaStatus = 'pending' | 'starting' | 'ready' | 'not_ready' | 'terminating' | 'failed';
+/** Replica metrics */
+export interface ReplicaMetrics {
+    requestCount: number;
+    errorCount: number;
+    latency: number;
+    cpu: number;
+    memory: number;
+}
+/** Deployment event */
+export interface DeploymentEvent {
+    id: string;
+    timestamp: Date;
+    type: DeploymentEventType;
+    message: string;
+    severity: 'info' | 'warning' | 'error';
+    metadata?: Record<string, unknown>;
+}
+/** Deployment event type */
+export type DeploymentEventType = 'created' | 'updated' | 'scaled' | 'rolled_back' | 'traffic_shifted' | 'health_check_failed' | 'health_check_passed' | 'replica_started' | 'replica_stopped' | 'error' | 'warning';
+/** Batch inference job */
+export interface BatchInferenceJob {
+    id: string;
+    name: string;
+    modelId: string;
+    modelVersion: string;
+    status: BatchJobStatus;
+    config: BatchJobConfig;
+    progress?: BatchJobProgress;
+    result?: BatchJobResult;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+/** Batch job status */
+export type BatchJobStatus = 'pending' | 'preparing' | 'running' | 'completing' | 'completed' | 'failed' | 'cancelled';
+/** Batch job config */
+export interface BatchJobConfig {
+    input: BatchInput;
+    output: BatchOutput;
+    compute: BatchCompute;
+    options?: BatchOptions;
+}
+/** Batch input */
+export interface BatchInput {
+    source: 's3' | 'gcs' | 'azure' | 'local';
+    path: string;
+    format: 'csv' | 'json' | 'jsonl' | 'parquet' | 'tfrecord';
+    schema?: SchemaDefinition;
+}
+/** Batch output */
+export interface BatchOutput {
+    destination: 's3' | 'gcs' | 'azure' | 'local';
+    path: string;
+    format: 'csv' | 'json' | 'jsonl' | 'parquet';
+    includeInput?: boolean;
+}
+/** Batch compute */
+export interface BatchCompute {
+    instanceType: MLInstanceType;
+    instanceCount: number;
+    maxRuntime?: number;
+}
+/** Batch options */
+export interface BatchOptions {
+    batchSize?: number;
+    maxConcurrency?: number;
+    retries?: number;
+    failOnError?: boolean;
+    shuffle?: boolean;
+}
+/** Batch job progress */
+export interface BatchJobProgress {
+    totalRecords: number;
+    processedRecords: number;
+    failedRecords: number;
+    percentage: number;
+    estimatedTimeRemaining?: number;
+}
+/** Batch job result */
+export interface BatchJobResult {
+    recordsProcessed: number;
+    recordsFailed: number;
+    outputPath: string;
+    outputSize: number;
+    duration: number;
+    errors?: BatchError[];
+}
+/** Batch error */
+export interface BatchError {
+    recordIndex?: number;
+    message: string;
+    count: number;
+}
+/** Edge model deployment */
+export interface EdgeModelDeployment {
+    id: string;
+    name: string;
+    modelId: string;
+    modelVersion: string;
+    targetFormat: EdgeModelFormat;
+    status: EdgeDeploymentStatus;
+    config: EdgeDeploymentConfig;
+    devices?: EdgeDeviceDeployment[];
+    createdAt: Date;
+}
+/** Edge model format */
+export type EdgeModelFormat = 'tflite' | 'coreml' | 'onnx' | 'openvino' | 'tensorrt' | 'nnapi' | 'edgetpu' | 'custom';
+/** Edge deployment status */
+export type EdgeDeploymentStatus = 'converting' | 'optimizing' | 'ready' | 'deploying' | 'deployed' | 'failed';
+/** Edge deployment config */
+export interface EdgeDeploymentConfig {
+    optimization: EdgeOptimizationConfig;
+    targets: EdgeTarget[];
+    updatePolicy?: EdgeUpdatePolicy;
+}
+/** Edge optimization config */
+export interface EdgeOptimizationConfig {
+    quantization?: QuantizationConfig;
+    pruning?: PruningConfig;
+    compilation?: CompilationConfig;
+}
+/** Quantization config */
+export interface QuantizationConfig {
+    enabled: boolean;
+    type: 'int8' | 'fp16' | 'dynamic' | 'static';
+    calibrationData?: string;
+}
+/** Pruning config */
+export interface PruningConfig {
+    enabled: boolean;
+    sparsity: number;
+    method: 'magnitude' | 'structured' | 'movement';
+}
+/** Compilation config */
+export interface CompilationConfig {
+    enabled: boolean;
+    target?: string;
+    optimizationLevel?: number;
+}
+/** Edge target */
+export interface EdgeTarget {
+    platform: 'android' | 'ios' | 'linux' | 'windows' | 'rtos' | 'mcu';
+    architecture: 'arm64' | 'armv7' | 'x86_64' | 'x86' | 'custom';
+    accelerator?: 'gpu' | 'npu' | 'dsp' | 'tpu' | 'none';
+}
+/** Edge update policy */
+export interface EdgeUpdatePolicy {
+    type: 'manual' | 'automatic' | 'scheduled';
+    schedule?: string;
+    rolloutStrategy?: 'all' | 'canary' | 'staged';
+    rollbackOnFailure?: boolean;
+}
+/** Edge device deployment */
+export interface EdgeDeviceDeployment {
+    deviceId: string;
+    deviceName?: string;
+    status: 'pending' | 'downloading' | 'installing' | 'running' | 'failed';
+    version: string;
+    lastUpdate?: Date;
+    metrics?: EdgeDeviceMetrics;
+}
+/** Edge device metrics */
+export interface EdgeDeviceMetrics {
+    inferenceCount: number;
+    averageLatency: number;
+    errorRate: number;
+    lastInference?: Date;
+}
+/** Load test */
+export interface MLLoadTest {
+    id: string;
+    name: string;
+    deploymentId: string;
+    status: LoadTestStatus;
+    config: LoadTestConfig;
+    results?: LoadTestResults;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+/** Load test status */
+export type LoadTestStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** Load test config */
+export interface LoadTestConfig {
+    duration: number;
+    rampUp?: number;
+    concurrency: ConcurrencyConfig;
+    requests: LoadTestRequests;
+    thresholds?: LoadTestThreshold[];
+}
+/** Concurrency config */
+export interface ConcurrencyConfig {
+    type: 'constant' | 'ramp' | 'step' | 'spike';
+    users: number;
+    maxUsers?: number;
+    stepSize?: number;
+    stepDuration?: number;
+}
+/** Load test requests */
+export interface LoadTestRequests {
+    endpoint: string;
+    method: 'POST' | 'GET';
+    payload?: unknown;
+    payloadFile?: string;
+    headers?: Record<string, string>;
+}
+/** Load test threshold */
+export interface LoadTestThreshold {
+    metric: 'latency_p95' | 'latency_p99' | 'error_rate' | 'throughput';
+    operator: 'lt' | 'gt' | 'lte' | 'gte';
+    value: number;
+}
+/** Load test results */
+export interface LoadTestResults {
+    summary: LoadTestSummary;
+    timeline: LoadTestTimeline;
+    latencyDistribution: LatencyDistribution;
+    errorAnalysis?: ErrorAnalysis;
+    passed: boolean;
+}
+/** Load test summary */
+export interface LoadTestSummary {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    requestsPerSecond: number;
+    latencyMean: number;
+    latencyP50: number;
+    latencyP95: number;
+    latencyP99: number;
+    errorRate: number;
+}
+/** Load test timeline */
+export interface LoadTestTimeline {
+    timestamps: Date[];
+    requests: number[];
+    latency: number[];
+    errors: number[];
+    concurrency: number[];
+}
+/** Latency distribution */
+export interface LatencyDistribution {
+    buckets: number[];
+    counts: number[];
+    percentiles: Record<number, number>;
+}
+/** Error analysis */
+export interface ErrorAnalysis {
+    byType: Record<string, number>;
+    byCode: Record<number, number>;
+    samples: ErrorSample[];
+}
+/** Error sample */
+export interface ErrorSample {
+    timestamp: Date;
+    code: number;
+    message: string;
+    request?: unknown;
+}
+/** Triton config */
+export interface TritonConfig {
+    modelRepository: string;
+    strictModelConfig?: boolean;
+    backends?: TritonBackend[];
+    httpPort?: number;
+    grpcPort?: number;
+    metricsPort?: number;
+    optimization?: TritonOptimization;
+}
+/** Triton backend */
+export interface TritonBackend {
+    name: string;
+    version?: string;
+    platforms?: string[];
+}
+/** Triton optimization */
+export interface TritonOptimization {
+    dynamicBatching?: DynamicBatchingConfig;
+    instanceGroup?: InstanceGroupConfig[];
+    tensorRT?: TensorRTConfig;
+}
+/** Dynamic batching config */
+export interface DynamicBatchingConfig {
+    preferredBatchSize?: number[];
+    maxQueueDelayMicroseconds?: number;
+}
+/** Instance group config */
+export interface InstanceGroupConfig {
+    count: number;
+    kind: 'cpu' | 'gpu';
+    gpus?: number[];
+}
+/** TensorRT config */
+export interface TensorRTConfig {
+    enabled: boolean;
+    precision: 'fp32' | 'fp16' | 'int8';
+    maxWorkspaceSize?: number;
+}
+/** TensorFlow Serving config */
+export interface TFServingConfig {
+    modelBasePath: string;
+    modelName: string;
+    restPort?: number;
+    grpcPort?: number;
+    batching?: TFBatchingConfig;
+}
+/** TF batching config */
+export interface TFBatchingConfig {
+    maxBatchSize: number;
+    batchTimeoutMicros: number;
+    numBatchThreads?: number;
+}
+/** TorchServe config */
+export interface TorchServeConfig {
+    modelStore: string;
+    models?: TorchServeModel[];
+    inferencePort?: number;
+    managementPort?: number;
+    metricsPort?: number;
+}
+/** TorchServe model */
+export interface TorchServeModel {
+    modelName: string;
+    version?: string;
+    minWorkers?: number;
+    maxWorkers?: number;
+    batchSize?: number;
+    maxBatchDelay?: number;
+}
+/** ONNX Runtime config */
+export interface ONNXRuntimeConfig {
+    modelPath: string;
+    providers?: ONNXProvider[];
+    sessionOptions?: ONNXSessionOptions;
+}
+/** ONNX provider */
+export type ONNXProvider = 'CPUExecutionProvider' | 'CUDAExecutionProvider' | 'TensorrtExecutionProvider' | 'OpenVINOExecutionProvider' | 'CoreMLExecutionProvider';
+/** ONNX session options */
+export interface ONNXSessionOptions {
+    intraOpNumThreads?: number;
+    interOpNumThreads?: number;
+    graphOptimizationLevel?: 'disabled' | 'basic' | 'extended' | 'all';
+    executionMode?: 'sequential' | 'parallel';
+}
+//# sourceMappingURL=model-deployment.d.ts.map