/**
 * OEE (Overall Equipment Effectiveness) Types
 */
export interface OeeRawData {
    plannedTime: number;
    runTime: number;
    totalCount: number;
    goodCount: number;
    idealCycleTime: number;
}
export interface OeeInput {
    rawData: OeeRawData;
}
export interface OeeResult {
    factors: {
        availability: number;
        performance: number;
        quality: number;
        oee: number;
    };
    percentages: {
        availability: number;
        performance: number;
        quality: number;
        oee: number;
    };
}
/**
 * Cpk (Process Capability Index) Types
 */
export interface CpkInput {
    usl: number;
    lsl: number;
    mean: number;
    stdDev: number;
}
export interface CpkResult {
    cp: number;
    cpk: number;
    cpu: number;
    cpl: number;
    withinSpecPercent: number;
    sigmaLevel: number;
}
/**
 * Cycle Time Analysis Types
 */
export interface CycleTimeInput {
    measurements: number[];
    target?: number;
}
export interface CycleTimeResult {
    count: number;
    average: number;
    min: number;
    max: number;
    range: number;
    stdDev: number;
    cv: number;
}
/**
 * Takt Time Types
 */
export type TimeUnit = 'seconds' | 'minutes' | 'hours';
export interface TaktTimeInput {
    availableTime: number;
    demand: number;
    timeUnit: TimeUnit;
}
export interface TaktTimeResult {
    taktTime: number;
    maxRatePerHour: number;
}
/**
 * AQL (Acceptable Quality Level) Types
 */
export type InspectionLevel = 'I' | 'II' | 'III' | 'S-1' | 'S-2' | 'S-3' | 'S-4';
export interface AqlInput {
    /** Lot size (number of units in the batch) */
    lotSize: number;
    /**
     * Acceptable Quality Level (e.g., 0.065, 0.1, 0.25, 0.4, 0.65, 1.0, 1.5, 2.5, 4.0, 6.5,
     * 10, 15, 25). Per ISO 2859-1, values above 10 apply to nonconformities per 100 items only.
     */
    aqlLevel: number;
    /** Inspection level (I, II, III for general; S-1 to S-4 for special) */
    inspectionLevel: InspectionLevel;
}
export interface AqlResult {
    /** Sample size code letter */
    sampleCode: string;
    /** Number of samples to inspect */
    sampleSize: number;
    /** Accept number (max defects to accept) */
    acceptNumber: number;
    /** Reject number (min defects to reject) */
    rejectNumber: number;
    /** Sampling percentage of lot */
    samplingPercent: number;
    /**
     * The AQL column actually applied from the embedded ISO 2859-1 table
     * (0.065–25). 0 for the negative-aqlLevel zero-plan sentinel.
     */
    aqlUsed: number;
    /**
     * true when `aqlUsed !== aqlLevel` — the requested AQL is not a column of the
     * embedded table (e.g. 40 → 25, 0.01 → 0.065, 5.0 → 4.0) and the returned plan
     * is for a DIFFERENT quality level than requested.
     */
    aqlAdjusted: boolean;
}
/**
 * Downtime Cost Types
 */
export interface DowntimeInput {
    hourlyRate: number;
    laborCostPerHour: number;
    downtimeMinutes: number;
    plannedProductionUnits: number;
    unitPrice: number;
}
export interface DowntimeResult {
    downtimeHours: number;
    lostUnits: number;
    laborCost: number;
    equipmentCost: number;
    lostRevenue: number;
    totalCost: number;
}
/**
 * DPMO (Defects Per Million Opportunities) Types
 */
export interface DpmoInput {
    defects: number;
    units: number;
    opportunities: number;
}
export interface DpmoResult {
    dpmo: number;
    sigmaLevel: number;
    yield: number;
    dpu: number;
    defectRate: number;
}
/**
 * Line Balancing Types
 */
export interface BalancingTask {
    id: string;
    name: string;
    time: number;
    predecessors: string[];
}
export interface LineBalancingInput {
    tasks: BalancingTask[];
    cycleTime: number;
}
export interface WorkStation {
    id: number;
    tasks: {
        id: string;
        name: string;
        time: number;
    }[];
    totalTime: number;
    idleTime: number;
}
export interface PositionalWeight {
    id: string;
    name: string;
    time: number;
    weight: number;
}
export interface LineBalancingResult {
    stations: WorkStation[];
    numStations: number;
    theoreticalMin: number;
    lineEfficiency: number;
    balanceDelay: number;
    smoothnessIndex: number;
    positionalWeights: PositionalWeight[];
}
/**
 * MTBF (Mean Time Between Failures) Types
 */
export interface MtbfInput {
    /** Total operating time in hours */
    totalOperatingTime: number;
    /** Total repair/downtime in hours */
    totalRepairTime: number;
    /** Number of failures */
    numberOfFailures: number;
}
export interface MtbfResult {
    /** Mean Time Between Failures (hours) */
    mtbf: number;
    /** Mean Time To Repair (hours) */
    mttr: number;
    /** Availability (0-100 %) */
    availability: number;
    /** Failure rate (failures per hour) */
    failureRate: number;
    /** Reliability at time T (using exponential distribution), where T = MTBF */
    reliabilityAtMtbf: number;
}
/**
 * Ppk (Process Performance Index) Types
 */
export interface PpkInput {
    usl: number;
    lsl: number;
    mean: number;
    stdDev: number;
}
export interface PpkResult {
    pp: number;
    ppk: number;
    ppu: number;
    ppl: number;
    withinSpecPercent: number;
    sigmaLevel: number;
    /** @deprecated Use `ppu`. Retained as an alias for backward compatibility; removed in a future release. */
    ppUpper: number;
    /** @deprecated Use `ppl`. Retained as an alias for backward compatibility; removed in a future release. */
    ppLower: number;
    /** @deprecated Use `sigmaLevel`. Retained as an alias for backward compatibility; removed in a future release. */
    sigma: number;
}
/**
 * PPM (Parts Per Million) Conversion Types
 */
export type ConvertFrom = 'defectRate' | 'ppm' | 'sigma';
export interface PpmInput {
    convertFrom: ConvertFrom;
    value: number;
}
export interface PpmResult {
    defectRate: number;
    ppm: number;
    dpmo: number;
    sigma: number;
    yieldRate: number;
}
/**
 * RPN (Risk Priority Number) Types
 */
export interface RpnInput {
    severity: number;
    occurrence: number;
    detection: number;
}
export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
export interface RpnResult {
    rpn: number;
    riskLevel: RiskLevel;
    severityScore: number;
    occurrenceScore: number;
    detectionScore: number;
}
/**
 * Control Chart (SPC) Types
 */
export type ControlChartType = 'xbarR' | 'xbarS' | 'imr';
export interface ControlChartInput {
    chartType: ControlChartType;
    subgroups: number[][];
}
export interface ControlLimit {
    centerLine: number;
    ucl: number;
    lcl: number;
}
export interface SubgroupStat {
    index: number;
    mean: number;
    range?: number;
    stdDev?: number;
    outOfControl: boolean;
}
export interface ControlChartResult {
    chartType: ControlChartType;
    subgroupSize: number;
    xBarLimits: ControlLimit;
    rOrSLimits: ControlLimit;
    subgroupStats: SubgroupStat[];
    grandMean: number;
    sigmaEstimate: number;
    outOfControlPoints: number[];
    processCapable: boolean;
}
/**
 * Yield (FPY/RTY) Types
 */
export interface YieldInput {
    /** Array of process steps, each containing [goodUnits, totalUnits] */
    steps: Array<{
        good: number;
        total: number;
    }>;
}
export interface YieldResult {
    /** First Pass Yield for each step (0-100 %) */
    fpyPerStep: number[];
    /** Average FPY across all steps (0-100 %) */
    averageFpy: number;
    /** Rolled Throughput Yield = product of all FPYs (0-100 %) */
    rty: number;
    /** Total input units (first step) */
    totalInput: number;
    /** Expected output after all steps */
    expectedOutput: number;
}
/**
 * Gage R&R (MSA) Types — AIAG MSA 4th Edition
 */
export interface GageRRInput {
    measurements: number[][][];
    tolerance?: number;
}
export interface GageRRResult {
    ev: number;
    av: number;
    grr: number;
    pv: number;
    tv: number;
    percentGRR: number;
    percentTolerance: number | null;
    ndc: number;
    status: 'acceptable' | 'marginal' | 'unacceptable';
}
/**
 * Cmk (Machine Capability Index) Types
 */
export interface CmkInput {
    measurements: number[];
    lsl: number;
    usl: number;
}
export interface CmkResult {
    mean: number;
    stdDev: number;
    cm: number;
    cmk: number;
    isCapable: boolean;
}
/**
 * Weibull Reliability Analysis Types
 */
export interface WeibullInput {
    failureTimes: number[];
    missionTime?: number;
}
export interface WeibullResult {
    beta: number;
    eta: number;
    mttf: number;
    r2: number;
    reliability: number | null;
    b10Life: number;
    b50Life: number;
    failureMode: 'infant' | 'random' | 'wearout';
}
/**
 * Action Priority (AP) Types — AIAG-VDA 2019
 */
export type ActionPriorityLevel = 'H' | 'M' | 'L';
/** Inclusive rating range of one AP lookup band; array index = group index. */
export interface ApRatingBand {
    min: number;
    max: number;
}
export interface ActionPriorityInput {
    severity: number;
    occurrence: number;
    detection: number;
}
export interface ActionPriorityResult {
    actionPriority: ActionPriorityLevel;
    rpn: number;
    severityGroup: number;
    occurrenceGroup: number;
    detectionGroup: number;
}
/**
 * Cpk to Occurrence Mapping Types
 */
export interface CpkToOccurrenceInput {
    cpk: number;
}
export interface CpkToOccurrenceResult {
    occurrence: number;
    description: string;
    cpkRange: string;
}
/**
 * Nelson Rules Types
 */
export interface NelsonRulesInput {
    values: number[];
    centerLine: number;
    sigma: number;
    rules?: number[];
}
export interface NelsonViolation {
    rule: number;
    description: string;
    indices: number[];
}
export interface NelsonRulesResult {
    violations: NelsonViolation[];
    hasViolation: boolean;
}
/**
 * Pareto Analysis Types
 */
export interface ParetoItem {
    name: string;
    value: number;
}
export interface ParetoInput {
    items: ParetoItem[];
    thresholdA?: number;
    thresholdB?: number;
}
export interface ParetoClassification {
    name: string;
    value: number;
    percentage: number;
    cumulative: number;
    rank: number;
    category: 'A' | 'B' | 'C';
}
export interface ParetoResult {
    items: ParetoClassification[];
    summary: {
        a: {
            count: number;
            totalValue: number;
            percentage: number;
        };
        b: {
            count: number;
            totalValue: number;
            percentage: number;
        };
        c: {
            count: number;
            totalValue: number;
            percentage: number;
        };
    };
    totalValue: number;
}
//# sourceMappingURL=types.d.ts.map