import type { Die } from '../core/dies.js';
import type { DieMetadata, WaferMetadata } from '../core/metadata.js';
import type { Wafer } from '../core/wafer.js';
import type { Reticle } from '../core/reticle.js';
import { type View, type ViewOptions, type PlotMode } from './buildView.js';
/**
 * Test result for a single die position, as output by the prober.
 * `x` and `y` are **die grid positions** (prober step coordinates) — integers
 * such as −7, 0, 5.  They are NOT millimetre values.
 */
export interface DieResult {
    /**
     * Die grid X position (prober step coordinate). Omit (together with `y`)
     * when this die has no reported spatial position at all — it still counts
     * toward every non-spatial stat (yield, bin counts, per-test
     * histograms/correlation/scatter) but is never placed on a wafer
     * map/gallery canvas and never enters ring/quadrant/sector/reticle/
     * cluster/pattern analysis. A die must be either fully positioned (both
     * `x` and `y`) or fully unpositioned (neither) — `buildWaferMap` rejects
     * the half-state.
     */
    x?: number;
    /** Die grid Y position (prober step coordinate). See `x`. */
    y?: number;
    /**
     * Test values keyed by test number — a stable per-test identity such as
     * STDF TEST_NUM or an equivalent application-defined integer. Keying by test
     * number is unaffected by test ordering changes in the test program.
     * Example: `{ 1050: 1.42e-3, 1060: 0.487, 1070: 8.3e-12 }`
     */
    testValues?: Record<number, number>;
    /**
     * Recorded per-test pass/fail verdicts keyed by test number (true = pass),
     * parallel to `testValues`. Parametric tests carry a value in `testValues`
     * and may optionally carry the tester's recorded verdict here (e.g. STDF
     * PTR TEST_FLG); functional tests (`testType: 'F'` in `testDefs`) carry a
     * verdict here ONLY — they have no measured value.
     * Example: `{ 2001: true, 2002: false }`
     */
    testPass?: Record<number, boolean>;
    /** Hard bin assignment (physical sort result). */
    hbin?: number;
    /** Soft bin assignment (test-program failure category). */
    sbin?: number;
    /**
     * Number of times this die position appeared in the input results array.
     * Populated automatically by `buildWaferMap` — do not set manually.
     * Only present when the die was tested more than once.
     */
    retestCount?: number;
    /**
     * STDF `site_num` — which parallel test site tested this die.
     * Only meaningful when more than one distinct value appears across the wafer
     * (i.e. the wafer was tested with a multi-site probe card).
     */
    siteNum?: number;
    /**
     * STDF `pir.part_id` — tester-assigned identifier for this tested unit.
     * At most fabs this encodes the probe sequence (the order in which the prober
     * stepped across the wafer), but the field is semantically neutral — its
     * meaning is fab-specific.
     */
    partId?: number;
    /** Per-die metadata — all fields appear automatically in hover tooltips. See `DieMetadata → §12.4`. */
    metadata?: DieMetadata;
}
/** Wafer geometry parameters — all optional; any omitted fields are inferred. */
export interface WaferConfig {
    /** Wafer diameter in mm.  Inferred from grid extent × pitch when omitted. */
    diameter?: number;
    /**
     * The prober coordinate `(x, y)` that lies at the physical centre of the
     * wafer.  Supply this for **partial or sparse** data (a half wafer, a single
     * quadrant, an edge ring, a small cluster) or whenever the prober origin is
     * not the wafer centre.
     *
     * When omitted, the centre is inferred as the midpoint of the observed die
     * positions — correct only when the data spans a full, roughly symmetric
     * wafer.  For partial data that assumption is wrong: the data midpoint is not
     * the wafer centre, so dies would be mis-positioned relative to the true
     * boundary and notch.  Setting this anchors placement to the real centre.
     *
     * Note: this does not change the public `die.x` / `die.y` labels — those are
     * always the original prober coordinates.  It only fixes physical placement.
     */
    center?: {
        x: number;
        y: number;
    };
    /**
     * Orientation mark direction.  Standard dimensions are derived automatically
     * from the wafer diameter:
     * - ≤ 100 mm → 32.5 mm orientation flat (SEMI M1)
     * - ≤ 150 mm → 57.5 mm orientation flat (SEMI M1)
     * - > 150 mm → V-notch (~3.5 mm wide, 1.25 mm deep — SEMI M1)
     */
    notch?: {
        type: 'top' | 'bottom' | 'left' | 'right';
    };
    /**
     * Wafer orientation in degrees.  Positive values rotate the map
     * clockwise.  The notch/flat position is set by `notch.type` and is not
     * affected by this value — `orientation` rotates the *die grid* on the display.
     *
     * Common values: 0 (default), 90, 180, 270.
     */
    orientation?: number;
    metadata?: WaferMetadata;
    /**
     * Physical edge exclusion zone in mm measured from the wafer edge inward.
     * Dies whose centres fall inside this band are rendered dimmed and marked
     * `edgeExcluded: true` on the returned Die objects.
     */
    edgeExclusion?: number;
}
/**
 * Die geometry and coordinate-system parameters — all optional.
 * When omitted, dimensions are estimated from the grid layout.
 */
export interface DieConfig {
    /** Die width in mm (= X pitch). */
    width?: number;
    /** Die height in mm (= Y pitch). */
    height?: number;
    /**
     * Where the prober places coordinate (0,0) on the wafer grid.
     *
     * - `'center'`  (default) — grid already near (0,0); centroid offset applied.
     * - `'LL'`      — (0,0) at lower-left; positive x right, positive y up.
     * - `'UL'`      — (0,0) at upper-left; positive x right, positive y **down**.
     * - `'LR'`      — (0,0) at lower-right; positive x **left**, positive y up.
     * - `'UR'`      — (0,0) at upper-right; positive x left, positive y down.
     * - `'custom'`  — apply explicit `offset` (in grid steps) to centre the grid.
     *
     */
    coordinateOrigin?: {
        type: 'center' | 'LL' | 'UL' | 'LR' | 'UR' | 'custom';
        /** Grid-step offset to the true centre.  Used only when type is `'custom'`. */
        offset?: {
            x: number;
            y: number;
        };
    };
    /**
     * Direction in which the prober Y axis increases.
     * `'up'` (default) is standard Cartesian; `'down'` is row/matrix convention
     * (row 1 at top).  The library flips the display Y axis so the map renders
     * with +Y pointing up regardless of the prober convention.
     */
    yAxisDirection?: 'up' | 'down';
    /**
     * Direction in which the prober X axis increases.
     * `'right'` (default) is standard; `'left'` is used for backside probing or
     * mirrored coordinate systems.
     */
    xAxisDirection?: 'right' | 'left';
}
/**
 * Reticle (stepper field) overlay configuration.
 * Dimensions are in die counts; `anchorDie` pins a specific die index to the
 * reticle's min-x/min-y corner (bottom-left, since +Y is up).
 */
export interface ReticleConfig {
    /** Field width in number of dies. */
    width: number;
    /** Field height in number of dies. */
    height: number;
    /**
     * Die grid index (x, y) — in original die coordinates (`die.x`/`die.y`) — that
     * sits at the reticle field's min-x/min-y corner (bottom-left, since +Y is up).
     * That die becomes the leftmost, bottom-most die of the field it belongs to;
     * every field boundary is placed relative to it. Controls the phase
     * (alignment) of the reticle grid. Defaults to `{x: 0, y: 0}`.
     */
    anchorDie?: {
        x: number;
        y: number;
    };
}
/**
 * Lot-level stacking — collapse results from several wafers into a single map.
 * The aggregated result is used as the `results` for this map; any top-level
 * `results` field is ignored when `lotStack` is present.
 */
export interface LotStackConfig {
    /** One `DieResult[]` per wafer in the lot. */
    results: DieResult[][];
    /** Aggregation method applied per die position across all wafers. */
    method: 'mean' | 'median' | 'stddev' | 'min' | 'max' | 'count' | 'countBin' | 'mode' | 'percent';
    /** Required when `method` is `'countBin'` or `'percent'`. */
    targetBin?: number;
}
/**
 * Metadata for one test measurement.
 * Provides a human-readable name and optional unit for display in tooltips,
 * the colorbar, and the mode selector.
 */
export interface TestDef {
    /**
     * Stable per-test identity — an application-defined integer that uniquely
     * identifies this test within a test program (for example, STDF TEST_NUM).
     * Must match the key used in `DieResult.testValues` / `DieResult.testPass`.
     */
    testNumber: number;
    /** Human-readable test name, e.g. `"Idsat"` or `"Vth"`. */
    name: string;
    /** Physical unit string, e.g. `"A"`, `"V"`, `"Ω"`. Shown in tooltip and colorbar. */
    unit?: string;
    /**
     * When true, value normalization and the colorbar use log₁₀ scale for this test.
     * Silently falls back to linear when any die value is ≤ 0. Default: false.
     */
    logScale?: boolean;
    /**
     * Lower specification limit in the same units as the test value.
     * When set, values below this limit are considered out-of-spec.
     * Both limits are optional independently — some tests have one-sided limits.
     */
    limitLow?: number;
    /**
     * Upper specification limit in the same units as the test value.
     * When set, values above this limit are considered out-of-spec.
     */
    limitHigh?: number;
    /**
     * Test kind: `'P'` (parametric — a continuous measured value) or `'F'`
     * (functional — a pass/fail outcome, conventionally recorded as 1 = pass,
     * 0 = fail, e.g. an STDF FTR). Functional tests render on the wafer map
     * like any other test value, but are excluded from parametric statistics —
     * per-test descriptive stats, capability, correlation, distribution charts,
     * and regional value findings — where a mean or Cpk of a binary outcome
     * would be meaningless. Default: `'P'`.
     */
    testType?: 'P' | 'F';
}
/**
 * True when `def` describes a parametric (continuous-value) test — i.e. its
 * values are valid input for parametric statistics (mean, quartiles, Cpk,
 * correlation). Functional tests (`testType: 'F'`) record pass/fail outcomes,
 * not measurements. An undefined def or undefined `testType` defaults to
 * parametric, so untyped callers keep today's behaviour.
 */
export declare function isParametricTest(def: TestDef | undefined): boolean;
/**
 * Metadata for one bin number (hard bin or soft bin).
 * Hard bins and soft bins have independent number spaces (both 0–32767 per STDF V4)
 * so separate `hbinDefs` and `sbinDefs` arrays are used — never mixed.
 */
export interface BinDef {
    /** Numeric bin value this definition describes. */
    bin: number;
    /** Human-readable bin name, e.g. `"Pass"` or `"Contact Open"`. */
    name: string;
    /**
     * Optional CSS color override for this bin.
     * When set, overrides the active colour scheme for this bin value.
     */
    color?: string;
}
/**
 * Named definition for one `die.metadata` key, opting it into the `'metadata'`
 * plot mode's toolbar entry, color fill, and legend. Presence in
 * `metadataFields` is what makes a key selectable — wmap never guesses which
 * metadata keys are "categorical enough" to plot.
 */
export interface MetadataFieldDef {
    /** The `die.metadata` key this definition applies to. */
    key: string;
    /** Display name for the toolbar entry and map title. Defaults to a Title-Cased version of `key`. */
    label?: string;
    /**
     * Optional per-value name/color overrides. Distinct values not listed here
     * are still shown — auto-labeled with the raw (stringified) value and
     * auto-colored from an ordered palette.
     */
    values?: Array<{
        value: string;
        label?: string;
        color?: string;
    }>;
}
/** Input accepted by {@link buildWaferMap}.  All fields are optional. */
/** Fields common to both single-wafer and lot-stack inputs. */
export interface WaferMapInputBase {
    /** Wafer geometry — diameter, notch direction, orientation, edge exclusion. */
    waferConfig?: WaferConfig;
    /** Die size and coordinate-system conventions. */
    dieConfig?: DieConfig;
    /** Pre-built die array. When supplied, geometry generation is skipped. */
    dies?: Die[];
    /**
     * Reticle (stepper field) overlay.
     * When provided, `showReticle` defaults to `true` in the scene options.
     */
    reticleConfig?: ReticleConfig;
    /**
     * Bin values that count as pass for yield calculation.
     * Defaults to `[1]` (industry convention: bin 1 = pass).
     * Set to an empty array to suppress yield calculation.
     */
    passBins?: number[];
    /**
     * How to handle multiple `DieResult` entries for the same die position (retests).
     *
     * - `'last'`  (default) — keep the most recent result. Matches pre-existing behaviour
     *              and is appropriate when records are in probe order and the final touch
     *              is the authoritative result.
     * - `'first'` — keep the earliest result. Useful when the first touch is canonical
     *              or when the array is already sorted best-first.
     * - `'best'`  — keep the result with the best hard bin outcome. Pass beats fail
     *              (determined by `passBins`); within the same category, the lower hbin
     *              number wins. Requires `hbin` on each result — if either record in a
     *              comparison has no `hbin`, the existing record is kept. `sbin` and
     *              `testValues` are not used as ordering criteria.
     * - `'worst'` — inverse of `'best'`: fail beats pass; higher hbin number wins within
     *              each category. Same `hbin` requirement applies.
     *
     * Regardless of policy, `die.retestCount` is set on any die that was tested more than
     * once, so retest hotspots are always visible.
     */
    retestPolicy?: 'last' | 'first' | 'best' | 'worst';
    /**
     * Named test definitions — one per entry in `die.values[]`.
     * When provided, tooltips show `"Idsat: 1.23 A"` instead of `"Values: 1.23"`,
     * and the mode selector offers a per-test dropdown entry.
     */
    testDefs?: TestDef[];
    /**
     * Named hard bin definitions — one per distinct `hbin` value.
     * Hard bins and soft bins have independent number spaces (STDF V4: both 0–32767),
     * so they are defined separately.
     * When provided, the bin legend and tooltips show names like `"Pass"` instead of `"Bin 1"`.
     * A `color` on a `BinDef` overrides the active colour scheme for that bin.
     */
    hbinDefs?: BinDef[];
    /**
     * Named soft bin definitions — one per distinct `sbin` value.
     * Soft bins are the logical/test-program classification; hard bins are the physical sort result.
     * Both spaces range 0–32767 and may overlap — define them separately.
     */
    sbinDefs?: BinDef[];
    /**
     * Named definitions for `die.metadata` keys that should be selectable as the
     * `'metadata'` plot mode — a generic categorical view driven by whatever
     * per-die classification a host already has in `metadata` (project, vendor,
     * test site, wafer zone, …), distinct from test/bin results. A key only
     * appears in the toolbar when it's listed here (opt-in, never auto-detected)
     * and at least one die actually has that key set.
     */
    metadataFields?: MetadataFieldDef[];
    /**
     * Controls how edge-excluded dies (dies within the edge exclusion zone) are counted in yield.
     *
     * - `'exclude'` (default) — edge dies are excluded from both numerator and denominator.
     *   `yieldPercent` = `passDies / (passDies + failDies)` counting only non-edge dies.
     * - `'denominator-only'` — edge dies are counted in `totalDies` denominator but never
     *   as pass.  This gives gross die yield: pass count vs. total populated area.
     *   `yieldPercentGross` is also set on `YieldSummary` for unambiguous reference.
     */
    edgeDieYieldMode?: 'exclude' | 'denominator-only';
}
/** Single-wafer input — pass one wafer's die results directly. */
export interface WaferMapInputSingle extends WaferMapInputBase {
    /** Per-die test results from the prober. */
    results?: DieResult[];
    lotStack?: never;
}
/** Lot-stack input — collapse results from multiple wafers into a single aggregated map. */
export interface WaferMapInputLotStack extends WaferMapInputBase {
    /** Lot-level stacking — collapse results from several wafers into a single map. */
    lotStack: LotStackConfig;
    results?: never;
}
/**
 * Input accepted by {@link buildWaferMap}.
 * Use {@link WaferMapInputSingle} for a single wafer or {@link WaferMapInputLotStack}
 * for an aggregated lot-stack map. Passing both `results` and `lotStack` is a type error.
 */
export type WaferMapInput = WaferMapInputSingle | WaferMapInputLotStack;
/** Options forwarded to {@link buildView}. */
export interface WaferMapOptions extends ViewOptions {
    debug?: boolean;
}
export interface YieldSummary {
    /** Dies with a bin in `passBins`. */
    passDies: number;
    /** Full dies inside wafer boundary with a bin not in `passBins`. */
    failDies: number;
    /** Full dies whose centres fall within the edge exclusion zone. */
    edgeExcludedDies: number;
    /** Dies that straddle the wafer boundary. */
    partialDies: number;
    /** Total full dies inside wafer boundary used for yield (excludes edge and partial). */
    totalDies: number;
    /** `(passDies / totalDies) × 100` in [0, 100], or `null` when no bin data is present. */
    yieldPercent: number | null;
    /**
     * Gross die yield: `passDies / (passDies + failDies + edgeExcludedDies) × 100` in [0, 100].
     * Set when `edgeDieYieldMode: 'denominator-only'` was passed; `null` otherwise.
     */
    yieldPercentGross?: number | null;
}
/**
 * A non-fatal advisory raised while `buildWaferMap` inferred geometry from data.
 * Surface these to the user (a panel, a log, a status line) instead of letting
 * silent inference mask questionable input — an engineer reading a wafer map
 * built on guessed geometry must be told the geometry was guessed.
 */
export interface WaferWarning {
    /**
     * Stable machine-readable key for the advisory. Branch on this, not on
     * `message` (which is prose and may be reworded). Known codes:
     * - `'partial-coverage'` — data does not span a full symmetric wafer; the
     *   inferred diameter and centre may be wrong and dies may be mis-positioned.
     * - `'geometry-conflict'` — `waferConfig.diameter` and `dieConfig.width`/`height`
     *   were BOTH supplied, and the wafer is too small to contain the probed dies.
     *   Since a die with test results is a real prober position and is always fully
     *   on the wafer, the two supplied values contradict each other and the die
     *   positions are the trustworthy side. wmap does not silently resize a diameter
     *   you asserted — it reports this so you can correct one of them. Only raised
     *   when the pitch was supplied: pitch is a free scaling parameter, so with an
     *   inferred pitch "the dies don't fit" is not a statement about your data.
     * - `'inferred-pitch'` — `waferConfig.diameter` was supplied without a die pitch,
     *   so the pitch was derived as `diameter ÷ grid span`, assuming the grid spans
     *   the full wafer. That assumption fails whenever edge dies are absent, which
     *   silently scales every die position. Supply `dieConfig.width`/`height`.
     * - `'test-count-capped'` — raised by `analyzeWaferMap`: more tests were found in
     *   the die data than the analysis cap allows, so test-value analysis was skipped
     *   entirely and NO test findings were produced. Pass `testNumbers` to scope it.
     *
     * The union is intentionally open to string so future advisory codes can be
     * added without a breaking change; switch with a `default` branch.
     */
    code: 'partial-coverage' | 'geometry-conflict' | 'inferred-pitch' | 'test-count-capped' | (string & {});
    /** Human-readable explanation, suitable for direct display. */
    message: string;
    /**
     * How much this affects trust in what is on screen. Drives the built-in
     * warning indicator's colour and ordering; default `'warning'` when absent.
     *
     * - `'error'` — the map may be *positionally wrong* (dies drawn in the wrong
     *   place). Nothing downstream of the geometry can be trusted.
     * - `'warning'` — something the viewer expected is absent or degraded, but what
     *   is drawn is correct.
     * - `'info'` — worth knowing, no impact on correctness.
     */
    severity?: 'error' | 'warning' | 'info';
    /** Inference confidence in [0, 1] for the related quantity, when one exists. */
    confidence?: number;
}
export interface WaferMapResult {
    wafer: Wafer;
    dies: Die[];
    /**
     * The initial plot mode selected by `buildWaferMap` — `'value'` when test values are
     * present, `'hardBin'` otherwise. Used to initialise the toolbar to the most useful mode.
     */
    plotMode: PlotMode;
    /** Wafer metadata copied from `waferConfig.metadata`, or `null` if none was provided. */
    metadata: import('../core/metadata.js').WaferMetadata | null;
    /** `true` when the result was built from a `lotStack` aggregation. */
    isLotStack: boolean;
    /**
     * @internal Renderer-agnostic draw list consumed by `renderWaferMap` and `toCanvas`.
     * Not part of the public API — access the named fields on `WaferMapResult` instead.
     */
    view: View;
    /** Reticle configuration used to generate the overlay and reticle-local groupings. */
    reticleConfig?: ReticleConfig;
    /**
     * Coordinate space of `die.physX` / `die.physY` and wafer dimensions:
     * - **'mm'**         — at least one physical dimension was provided or could
     *                      be inferred; all spatial values are in real millimetres.
     * - **'normalized'** — only grid positions were supplied; coordinates are
     *                      proportionally correct but not in physical mm.
     */
    units: 'mm' | 'normalized';
    inference: {
        wafer: {
            confidence: number;
            method: string;
        };
        diePitch: {
            confidence: number;
            units: 'mm' | 'normalized';
        };
        grid: {
            confidence: number;
        };
        /**
         * @deprecated Use the promoted top-level `WaferMapResult.warnings` instead —
         * it is always present (empty when none) and carries structured
         * `{ code, message, confidence? }` entries you can branch on. This raw
         * string array is retained for backward compatibility and mirrors the
         * `message` of each structured warning.
         */
        warnings?: string[];
    };
    /**
     * Structured non-fatal advisories raised while inferring geometry from data.
     * Always present; empty when geometry was supplied or confidently inferred.
     * Branch on `warning.code` and display `warning.message`. The most important
     * case is `'partial-coverage'`: data that does not span a full symmetric
     * wafer, where the inferred diameter and centre may be wrong. Read this
     * programmatically rather than relying on console output.
     */
    warnings: WaferWarning[];
    /** Die population statistics. */
    dataCoverage: {
        /** Positioned dies inside the wafer boundary that have at least one value or bin. */
        filledDies: number;
        /** Total positioned dies inside the wafer boundary (including partial). Excludes unpositioned dies — see `unpositionedDies`. */
        totalDies: number;
        /** Positioned dies falling within the edge exclusion zone. */
        edgeExcludedDies: number;
        /**
         * Dies with no reported x/y position at all (see `Die.x`/`hasPosition`).
         * Always present, `0` when every die is positioned. These dies are
         * counted in `dies` and in every non-spatial stat (yield, bin counts,
         * per-test analysis) but never in `totalDies`/`filledDies`/`ratio`
         * above, and never drawn on the map/gallery canvas.
         */
        unpositionedDies: number;
        /** `filledDies / totalDies` in [0, 1] — `0` when there are no positioned dies, even if `unpositionedDies` is large. */
        ratio: number;
    };
    /** Yield statistics computed against `passBins`. */
    yield: YieldSummary;
    /** Generated reticle geometry — pass as `viewOptions.reticles` to `renderWaferMap` to show the reticle overlay. */
    reticles: Reticle[];
    /** Named hard bin definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
    hbinDefs?: BinDef[];
    /** Named soft bin definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
    sbinDefs?: BinDef[];
    /** Named test definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
    testDefs?: TestDef[];
    /** Named metadata-field definitions passed to `buildWaferMap`. Consumed automatically by the renderer — no need to pass again to `renderWaferMap`. */
    metadataFields?: MetadataFieldDef[];
    /**
     * Lot-stack aggregation method used when `lotStack` was passed to `buildWaferMap`.
     * `undefined` for single-wafer results.
     */
    aggrMethod?: string;
    /**
     * Number of wafers aggregated when `lotStack` was passed to `buildWaferMap`.
     * `undefined` for single-wafer results.
     */
    lotSize?: number;
}
/** Read a test value from a die by test number. */
export declare function getDieTestValue(die: Die, testNumber: number): number | undefined;
/**
 * Single read-path for "did this die pass test `testNumber`".
 *
 * Primary source: `die.testPass[testNumber]` (the tester's recorded verdict).
 * Migration fallback — the ONLY place this rule exists: a functional test
 * (`testType: 'F'`) with no `testPass` entry but a `testValues` entry of
 * exactly 0 or 1 is legacy encoding (1 = pass, 0 = fail) from callers that
 * predate `testPass`. The fallback is never applied to parametric tests,
 * whose values are measurements.
 *
 * Returns `undefined` when no verdict is recorded — callers must treat that
 * as no-data, never as a fail.
 */
export declare function getTestPassStatus(die: Pick<Die, 'testValues' | 'testPass'>, testNumber: number, testDef?: TestDef): boolean | undefined;
/**
 * True when the die carries any per-test data — a measured test value or a
 * recorded pass/fail verdict. The single source for "does this die have test
 * data", used by coverage, plot-mode inference, and the toolbar's value-mode
 * availability checks.
 */
export declare function dieHasTestData(die: Pick<Die, 'testValues' | 'testPass'>): boolean;
export declare function buildWaferMap(input: DieResult[] | WaferMapInput, options?: WaferMapOptions): WaferMapResult;
//# sourceMappingURL=buildWaferMap.d.ts.map