@stll/anonymize 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,939 @@
+import { Validator } from "@stll/stdnum";
+import { Match, PatternEntry, TextSearch } from "@stll/text-search";
+import { Tokenizer } from "@huggingface/tokenizers";
+
+//#region src/types.d.ts
+/**
+ * Source of a detected entity span.
+ * Ordered by detection layer in the pipeline.
+ */
+declare const DETECTION_SOURCES: {
+  readonly TRIGGER: "trigger";
+  readonly REGEX: "regex";
+  readonly DENY_LIST: "deny-list";
+  readonly LEGAL_FORM: "legal-form";
+  readonly GAZETTEER: "gazetteer";
+  readonly NER: "ner";
+  readonly COREFERENCE: "coreference";
+};
+type DetectionSource = (typeof DETECTION_SOURCES)[keyof typeof DETECTION_SOURCES];
+/**
+ * Priority levels for detection sources.
+ * Higher = more structurally reliable. Used during
+ * overlap resolution so deterministic detectors beat
+ * probabilistic ones regardless of raw score.
+ */
+declare const DETECTOR_PRIORITY: Record<DetectionSource, number>;
+/**
+ * A detected PII entity span in the source text.
+ * Every detection layer produces these.
+ */
+type Entity = {
+  start: number;
+  end: number;
+  label: string;
+  text: string;
+  score: number;
+  source: DetectionSource;
+};
+/**
+ * Entity after human review. Extends the base Entity
+ * with a review decision.
+ */
+type ReviewDecision = "confirmed" | "rejected" | "relabeled";
+type ReviewedEntity = Entity & {
+  decision?: ReviewDecision;
+  originalLabel?: string;
+};
+/**
+ * A single entry in the workspace-scoped gazetteer
+ * (deny list). Persisted in IndexedDB.
+ */
+type GazetteerEntry = {
+  id: string;
+  canonical: string;
+  label: string;
+  variants: string[];
+  workspaceId: string;
+  createdAt: number;
+  source: "manual" | "confirmed-from-model";
+};
+/** Extraction strategy — closed discriminated union. */
+type TriggerStrategy = {
+  type: "to-next-comma";
+} | {
+  type: "to-end-of-line";
+} | {
+  type: "n-words";
+  count: number;
+} | {
+  type: "company-id-value";
+} | {
+  type: "address";
+  maxChars?: number;
+};
+/** Validation rules — closed discriminated union. */
+type TriggerValidation = {
+  type: "starts-uppercase";
+} | {
+  type: "min-length";
+  min: number;
+} | {
+  type: "max-length";
+  max: number;
+} | {
+  type: "no-digits";
+} | {
+  type: "has-digits";
+} | {
+  type: "matches-pattern";
+  pattern: string;
+  flags?: string;
+};
+/** Auto-generated trigger variants — closed set. */
+type TriggerExtension = "add-colon" | "add-trailing-space" | "add-colon-space" | "normalize-spaces";
+/** V2 trigger config entry (JSON shape). */
+type TriggerGroupConfig = {
+  id?: string;
+  triggers: string[];
+  label: string;
+  strategy: TriggerStrategy;
+  extensions?: TriggerExtension[];
+  validations?: TriggerValidation[];
+  /** When true, include the trigger text in the
+   *  entity span (e.g., court names). */
+  includeTrigger?: boolean;
+};
+/** Compiled validation with pre-built regex. */
+type CompiledValidation = {
+  type: "starts-uppercase";
+  re: RegExp;
+} | {
+  type: "min-length";
+  min: number;
+} | {
+  type: "max-length";
+  max: number;
+} | {
+  type: "no-digits";
+  re: RegExp;
+} | {
+  type: "has-digits";
+  re: RegExp;
+} | {
+  type: "matches-pattern";
+  re: RegExp;
+};
+/**
+ * Runtime rule — one per trigger string after
+ * expansion. Fed to the Aho-Corasick automaton.
+ */
+type TriggerRule = {
+  trigger: string;
+  label: string;
+  strategy: TriggerStrategy;
+  validations: CompiledValidation[];
+  includeTrigger: boolean;
+};
+/**
+ * Anonymisation operator types. Each operator defines
+ * how a confirmed entity is replaced in the output.
+ */
+declare const OPERATOR_TYPES: readonly ["replace", "redact"];
+type OperatorType = (typeof OPERATOR_TYPES)[number];
+/** Per-label operator selection. Key is the entity label. */
+type OperatorConfig = {
+  /** Operator per label. Missing labels default to "replace". */
+  operators: Record<string, OperatorType>;
+  /** Custom replacement string for the redact operator. */
+  redactString: string;
+};
+/** Whether an operator produces a reversible redaction entry. */
+type OperatorReversibility = "reversible" | "irreversible";
+type AnonymisationOperator = {
+  type: OperatorType;
+  reversibility: OperatorReversibility;
+  /**
+   * Apply the operator to a single entity occurrence.
+   * Returns the replacement string to embed in the document.
+   */
+  apply: (text: string, label: string, placeholder: string, redactString: string) => string;
+};
+/**
+ * Redacted document output with stable entity mapping.
+ */
+type RedactionResult = {
+  redactedText: string;
+  /**
+   * Maps placeholder to original text. Only populated for
+   * reversible operators (replace). Empty for redact.
+   */
+  redactionMap: Map<string, string>;
+  /** Maps placeholder to the operator that produced it. */
+  operatorMap: Map<string, OperatorType>;
+  entityCount: number;
+};
+/**
+ * Configuration for the detection pipeline.
+ */
+type DenyListCategory = "Names" | "Places" | "Addresses" | "Courts" | "Financial" | "Government" | "Healthcare" | "Education" | "Political" | "Organizations" | "International";
+type PipelineConfig = {
+  threshold: number;
+  enableTriggerPhrases: boolean;
+  enableRegex: boolean;
+  enableNameCorpus: boolean;
+  enableDenyList: boolean;
+  denyListCountries?: string[];
+  denyListRegions?: string[];
+  denyListExcludeCategories?: string[];
+  enableGazetteer: boolean;
+  enableNer: boolean;
+  enableConfidenceBoost: boolean;
+  enableCoreference: boolean;
+  enableZoneClassification?: boolean;
+  enableHotwordRules?: boolean;
+  labels: string[];
+  workspaceId: string;
+};
+/**
+ * Canonical entity labels used across the pipeline.
+ * NER models may use different native labels; the bench
+ * NER wrapper maps model output to these canonical names.
+ *
+ * These labels are ephemeral: entities are regenerated on
+ * every pipeline run and never persisted to the database.
+ * Renaming a label here requires no migration.
+ */
+declare const DEFAULT_ENTITY_LABELS: readonly ["person", "organization", "phone number", "address", "email address", "date", "date of birth", "bank account number", "iban", "tax identification number", "identity card number", "registration number", "credit card number", "passport number", "monetary amount"];
+//#endregion
+//#region src/detectors/regex.d.ts
+type RegexMeta = {
+  label: string;
+  score: number;
+  /** Post-match stdnum validator for confirmation. */
+  validator?: Validator;
+};
+/** Flat pattern array for text-search. */
+declare const REGEX_PATTERNS: readonly string[];
+/** Parallel metadata. Index = pattern index. */
+declare const REGEX_META: readonly RegexMeta[];
+/**
+ * Get dynamically built date patterns from
+ * date-months.json. Returns a cached promise; the JSON
+ * is loaded only once.
+ */
+declare const getDatePatterns: () => Promise<string[]>;
+/** Date pattern metadata (all are score 1 dates). */
+declare const DATE_PATTERN_META: Readonly<RegexMeta>;
+/**
+ * Get dynamically built monetary amount patterns from
+ * currencies.json. Returns a cached promise; the JSON
+ * is loaded only once.
+ */
+declare const getCurrencyPatterns: () => Promise<string[]>;
+/** Currency pattern metadata (score 0.9). */
+declare const CURRENCY_PATTERN_META: Readonly<RegexMeta>;
+/**
+ * Process regex matches from the unified search.
+ * Receives all matches; filters to the regex slice
+ * via sliceStart/sliceEnd. Local index into META is
+ * match.pattern - sliceStart.
+ *
+ * For stdnum-derived patterns (those with a validator
+ * in META), the matched text is passed through the
+ * validator's validate() method. If validation fails,
+ * the match is discarded as a false positive.
+ */
+declare const processRegexMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, meta_: readonly RegexMeta[]) => Entity[];
+//#endregion
+//#region src/detectors/deny-list.d.ts
+type DenyListConfig = Pick<PipelineConfig, "enableDenyList" | "denyListCountries" | "denyListRegions" | "denyListExcludeCategories">;
+/**
+ * Source tag for each pattern in the automaton.
+ * "deny-list" = standard deny list entry
+ * "first-name" = name corpus first name
+ * "surname" = name corpus surname
+ * "title" = academic/professional title
+ */
+type PatternSource = "deny-list" | "first-name" | "surname" | "title";
+/**
+ * Pre-built deny list data. Constructed once by
+ * `buildDenyList`, reused across `processDenyListMatches`
+ * calls. Contains PatternEntry[] for the unified builder
+ * plus parallel label/source arrays for post-processing.
+ */
+type DenyListData = {
+  /**
+   * Maps pattern index → entity labels (plural).
+   * Same pattern can have multiple labels when it
+   * appears in multiple dictionaries (e.g., "Denver"
+   * is both a person name and a city name).
+   */
+  labels: string[][];
+  /** Maps pattern index → original pattern text. */
+  originals: string[];
+  /** Maps pattern index → source types (plural). */
+  sources: PatternSource[][];
+};
+/**
+ * Resolve which dictionaries to load based on country
+ * and category filters, load them, and build the deny
+ * list data. The returned data provides PatternEntry[]
+ * for the unified builder and parallel arrays for
+ * post-processing.
+ *
+ * Requires `@stll/anonymize-data` to be installed.
+ * Returns null if the data package is not available.
+ */
+declare const buildDenyList: (config: DenyListConfig, ctx?: PipelineContext) => Promise<DenyListData | null>;
+/**
+ * Ensure all deny-list support data (stopwords, allow
+ * list, person stopwords, generic roles) is loaded on
+ * the given context. Call this before
+ * processDenyListMatches / filterFalsePositives when
+ * the search instance was built on a different context
+ * (e.g. cachedSearch).
+ */
+declare const ensureDenyListData: (ctx?: PipelineContext) => Promise<void>;
+/**
+ * Process deny list matches from the unified search.
+ * Receives all matches; filters to the deny list slice
+ * via sliceStart/sliceEnd. Local index into data.labels,
+ * data.originals, data.sources is match.pattern - sliceStart.
+ *
+ * Two-pass approach to reduce false positives:
+ * 1. Collect all matches (case-insensitive,
+ *    whole-word via Rust automaton)
+ * 2. Require uppercase start in source text
+ * 3. For person names, require at least one
+ *    mid-sentence occurrence to prove proper noun
+ * 4. Return all occurrences of validated terms
+ */
+declare const processDenyListMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText: string, data: DenyListData, ctx?: PipelineContext) => Entity[];
+//#endregion
+//#region src/build-unified-search.d.ts
+type PatternSlice = {
+  start: number;
+  end: number;
+};
+type GazetteerData = {
+  /** Maps local pattern index to entry label. */
+  labels: string[];
+  /**
+   * Whether each pattern is fuzzy (distance > 0).
+   * Used by the post-processor to assign scores.
+   */
+  isFuzzy: boolean[];
+};
+type UnifiedSearchInstance = {
+  /** Regex + triggers + legal-forms. */
+  tsRegex: TextSearch;
+  /** Deny-list + street-types + gazetteer. */
+  tsLiterals: TextSearch;
+  slices: {
+    regex: PatternSlice;
+    legalForms: PatternSlice;
+    triggers: PatternSlice;
+    denyList: PatternSlice;
+    streetTypes: PatternSlice;
+    gazetteer: PatternSlice;
+  };
+  regexMeta: readonly RegexMeta[];
+  triggerRules: readonly TriggerRule[];
+  denyListData: DenyListData | null;
+  gazetteerData: GazetteerData | null;
+};
+declare const buildUnifiedSearch: (config: PipelineConfig, gazetteerEntries?: GazetteerEntry[], ctx?: PipelineContext) => Promise<UnifiedSearchInstance>;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Build a stable cache key for an entity that survives
+ * shallow copies (spread). Uses position + label so the
+ * key is identical for the original object and any
+ * `{ ...entity }` copy produced by mergeAndDedup.
+ */
+declare const corefKey: (e: Entity) => string;
+/**
+ * Compiled RegExp pattern used for coreference
+ * definition extraction.
+ */
+type DefinitionPattern = {
+  pattern: RegExp;
+};
+/**
+ * Cached data for the name corpus detector.
+ * Populated by initNameCorpus; consumed by
+ * detectNameCorpus and deny-list AC integration.
+ */
+type NameCorpusData = {
+  firstNames: ReadonlySet<string>;
+  surnames: ReadonlySet<string>;
+  titleTokens: ReadonlySet<string>;
+  excludedWords: ReadonlySet<string>;
+  /** Raw arrays exposed for deny-list AC integration. */
+  firstNamesList: readonly string[];
+  surnamesList: readonly string[];
+  titlesList: readonly string[];
+  excludedList: readonly string[];
+};
+/**
+ * All cached state for a single pipeline run (or
+ * sequence of runs sharing the same config). Replacing
+ * module-level singletons with this object enables
+ * concurrent pipelines with different configs and
+ * simplifies testing.
+ *
+ * Each field starts null and is populated lazily on
+ * first use by the corresponding loader function.
+ */
+type PipelineContext = {
+  search: UnifiedSearchInstance | null;
+  searchKey: string;
+  searchPromise: Promise<UnifiedSearchInstance> | null;
+  nameCorpus: NameCorpusData | null;
+  nameCorpusPromise: Promise<void> | null;
+  stopwords: ReadonlySet<string> | null;
+  stopwordsPromise: Promise<ReadonlySet<string>> | null;
+  allowList: ReadonlySet<string> | null;
+  allowListPromise: Promise<ReadonlySet<string>> | null;
+  personStopwords: ReadonlySet<string> | null;
+  personStopwordsPromise: Promise<ReadonlySet<string>> | null;
+  /** First-name exclusions for stopword filtering. */
+  firstNameExclusions: ReadonlySet<string> | null;
+  firstNameExclusionCorpusLen: number;
+  genericRoles: ReadonlySet<string> | null;
+  genericRolesPromise: Promise<ReadonlySet<string>> | null;
+  corefPatterns: DefinitionPattern[] | null;
+  corefPatternsPromise: Promise<DefinitionPattern[]> | null;
+  corefLoadAttempted: boolean;
+  roleStopSet: ReadonlySet<string> | null;
+  roleStopSetPromise: Promise<ReadonlySet<string>> | null;
+  zoneHeadingPatterns: RegExp[] | null;
+  zoneSigningPatterns: RegExp[] | null;
+  zoneInitPromise: Promise<void> | null;
+  /**
+   * Maps coreference entities to their source entity
+   * text. Populated by findCoreferenceSpans, consumed
+   * by buildPlaceholderMap for consistent placeholder
+   * numbering across aliases and source entities.
+   *
+   * Keyed by `start:end:label` composite string so
+   * lookups survive shallow copies (e.g. from
+   * mergeAndDedup's spread operator).
+   */
+  corefSourceMap: Map<string, string>;
+};
+/** Create a fresh, empty pipeline context. */
+declare const createPipelineContext: () => PipelineContext;
+/**
+ * Module-level default context. Used when callers
+ * don't provide an explicit context, preserving full
+ * backward compatibility with the existing API.
+ */
+//#endregion
+//#region src/pipeline.d.ts
+/** Strip leading/trailing whitespace and punctuation. */
+declare const sanitizeEntities: (entities: Entity[]) => Entity[];
+declare const mergeAndDedup: (...layers: Entity[][]) => Entity[];
+type NerInferenceFn = (fullText: string, labels: string[], threshold: number, signal?: AbortSignal) => Promise<Entity[]>;
+/**
+ * Options for {@link runPipeline}.
+ *
+ * @property cachedSearch Pre-built search instance.
+ *   When provided, `config` and `gazetteerEntries`
+ *   are not used for building; the caller must
+ *   ensure the instance matches both parameters.
+ */
+type PipelineOptions = {
+  fullText: string;
+  config: PipelineConfig;
+  gazetteerEntries: GazetteerEntry[];
+  nerInference?: NerInferenceFn | null;
+  onProgress?: (step: string, detail: string) => void;
+  cachedSearch?: UnifiedSearchInstance;
+  signal?: AbortSignal;
+  context?: PipelineContext;
+};
+/**
+ * Run the full detection pipeline.
+ *
+ * Two TextSearch instances scan the text (regex +
+ * literals). Results are dispatched to each
+ * detector's post-processor by pattern index range.
+ *
+ * Pass an AbortSignal to cancel the pipeline between
+ * stages. Throws a DOMException with name "AbortError"
+ * when cancelled.
+ *
+ * Pass an optional `context` to isolate cached state
+ * from other pipeline runs. If omitted, a module-level
+ * default context is used (backward compatible).
+ */
+declare const runPipeline: (options: PipelineOptions) => Promise<Entity[]>;
+//#endregion
+//#region src/redact.d.ts
+/**
+ * Build a stable mapping from entity text to numbered
+ * placeholders. Same real-world value always maps to the
+ * same placeholder (e.g., "Dr. Muller" and "Dr.  Muller"
+ * both become [PERSON_1]).
+ *
+ * Placeholder format: [LABEL_N] where LABEL is uppercase
+ * and N is a 1-based counter per label.
+ *
+ * @param ctx Pipeline context. Must be the same instance
+ *   passed to `runPipeline` (or `findCoreferenceSpans`)
+ *   so coreference placeholder links are preserved.
+ *   Defaults to `defaultContext` for single-tenant usage.
+ */
+declare const buildPlaceholderMap: (entities: Entity[], ctx?: PipelineContext) => Map<string, string>;
+/**
+ * Apply redactions to the source text, replacing each
+ * confirmed entity span using the configured operator.
+ *
+ * Co-references are consistent: if the same text appears
+ * multiple times, all occurrences get the same placeholder.
+ *
+ * @param ctx Pipeline context. Must be the same instance
+ *   passed to `runPipeline` (or `findCoreferenceSpans`)
+ *   so coreference placeholder links are preserved.
+ *   Defaults to `defaultContext` for single-tenant usage.
+ */
+declare const redactText: (fullText: string, entities: Entity[], config?: OperatorConfig, ctx?: PipelineContext) => RedactionResult;
+/**
+ * Serialize the redaction key to JSON for export.
+ * Includes operator metadata so the export is self-describing.
+ */
+declare const exportRedactionKey: (redactionMap: Map<string, string>, operatorMap: Map<string, OperatorType>) => string;
+/**
+ * De-anonymise text using a redaction key.
+ * Replaces placeholders back with original values.
+ * Only works for reversible operators (replace).
+ */
+declare const deanonymise: (redactedText: string, redactionMap: Map<string, string>) => string;
+//#endregion
+//#region src/operators.d.ts
+declare const OPERATOR_REGISTRY: {
+  readonly replace: AnonymisationOperator;
+  readonly redact: AnonymisationOperator;
+};
+/**
+ * Default operator config: replace for all labels.
+ * Preserves existing pipeline behaviour.
+ */
+declare const DEFAULT_OPERATOR_CONFIG: OperatorConfig;
+/**
+ * Resolve the operator for a label, falling back to "replace".
+ */
+declare const resolveOperator: (config: OperatorConfig, label: string) => OperatorType;
+//#endregion
+//#region src/detectors/legal-forms.d.ts
+/**
+ * Build legal form regex pattern strings.
+ * Returns an array of regex strings for the unified
+ * TextSearch builder. Empty if data package is not
+ * installed.
+ */
+declare const buildLegalFormPatterns: () => Promise<string[]>;
+/**
+ * Process legal form matches from the unified search.
+ * Receives all matches; filters to the legal forms
+ * slice via sliceStart/sliceEnd.
+ */
+declare const processLegalFormMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText?: string) => Entity[];
+//#endregion
+//#region src/detectors/triggers.d.ts
+/**
+ * Build trigger patterns and rules from data configs.
+ * Returns string[] for the unified TextSearch
+ * builder and the parallel rules array.
+ */
+declare const buildTriggerPatterns: () => Promise<{
+  patterns: string[];
+  rules: TriggerRule[];
+}>;
+/**
+ * Process trigger matches from the unified search.
+ * Receives all matches; filters to the trigger slice
+ * via sliceStart/sliceEnd. Uses fullText for value
+ * extraction (the unified search runs on lowercased
+ * text, but extraction needs original casing).
+ */
+declare const processTriggerMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText: string, rules: readonly TriggerRule[]) => Entity[];
+//#endregion
+//#region src/detectors/address-seeds.d.ts
+/**
+ * Build street type patterns for the unified search.
+ * Returns string[] for the unified TextSearch
+ * builder. Empty if data package is not installed.
+ */
+declare const buildStreetTypePatterns: () => Promise<string[]>;
+/**
+ * Process address seeds from the unified search.
+ * Receives all matches; filters to the street types
+ * slice via sliceStart/sliceEnd. Uses fullText and
+ * existingEntities for seed collection, clustering,
+ * expansion, and scoring.
+ *
+ * Runs as a post-processor after all other detectors,
+ * using their output as seed sources.
+ */
+declare const processAddressSeeds: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText: string, existingEntities: Entity[]) => Promise<Entity[]>;
+//#endregion
+//#region src/detectors/gazetteer.d.ts
+/**
+ * Build TextSearch-compatible patterns from gazetteer
+ * entries. Returns:
+ * - Exact literal patterns for all terms
+ * - Fuzzy patterns (distance: 2) for terms >= 4 chars
+ * - Parallel metadata arrays for post-processing
+ *
+ * Patterns are ordered: all exact first, then all
+ * fuzzy. The isFuzzy array marks which are which.
+ */
+declare const buildGazetteerPatterns: (entries: GazetteerEntry[]) => {
+  patterns: PatternEntry[];
+  data: GazetteerData;
+};
+/**
+ * Process gazetteer matches from the unified literal
+ * search. Receives all matches; filters to the
+ * gazetteer slice via sliceStart/sliceEnd.
+ *
+ * Exact matches get score 0.9; fuzzy matches get
+ * 0.85. Fuzzy matches that overlap an exact match
+ * are dropped.
+ *
+ * For exact matches, attempts prefix extension for
+ * legal suffixes ("a.s.", "GmbH", "s.r.o." after
+ * the matched term).
+ */
+declare const processGazetteerMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText: string, data: GazetteerData) => Entity[];
+//#endregion
+//#region src/detectors/coreference.d.ts
+type DefinedTerm = {
+  alias: string;
+  label: string;
+  /** Position of the definition in the source text */
+  definitionStart: number;
+  /** Original entity text the alias refers to */
+  sourceText: string;
+};
+declare const extractDefinedTerms: (fullText: string, entities: Entity[], ctx?: PipelineContext) => Promise<DefinedTerm[]>;
+/**
+ * Find all occurrences of defined-term aliases in the
+ * full text. Returns Entity spans for each match.
+ *
+ * Respects word boundaries: "Kupující" must not match
+ * inside "Kupujícímu". A match is valid only if the
+ * character before the start and after the end are NOT
+ * word characters (letter/digit).
+ *
+ * Populates `ctx.corefSourceMap` with entries linking
+ * each coref entity to its source entity text, for
+ * consistent placeholder numbering.
+ */
+declare const findCoreferenceSpans: (fullText: string, terms: DefinedTerm[], ctx?: PipelineContext) => Entity[];
+//#endregion
+//#region src/detectors/org-propagation.d.ts
+/**
+ * After the main detection pass, collect organization
+ * entities with a legal form suffix, strip the suffix
+ * to get the base name, and re-scan the full text for
+ * bare mentions of that base name. Returns new entities
+ * for occurrences not already covered.
+ */
+declare const propagateOrgNames: (entities: Entity[], fullText: string) => Entity[];
+//#endregion
+//#region src/detectors/names.d.ts
+/**
+ * Load name corpus data from JSON config files.
+ * Safe to call multiple times; only loads once per
+ * context. Must be called before detectNameCorpus or
+ * the getNameCorpus*() accessors are used.
+ */
+declare const initNameCorpus: (ctx?: PipelineContext) => Promise<void>;
+/**
+ * Detect person names by looking up tokens against the
+ * name corpus, then chaining adjacent name-like tokens.
+ *
+ * Requires initNameCorpus() to have been called first.
+ * If not initialized, returns an empty array.
+ *
+ * Scoring:
+ *   TITLE + NAME/SURNAME       → 0.95
+ *   NAME + NAME/SURNAME        → 0.9
+ *   SURNAME + NAME/SURNAME     → 0.9
+ *   NAME + CAPITALIZED         → 0.7
+ *   ABBREVIATION + NAME        → 0.7
+ *   Standalone NAME            → 0.5 (low confidence)
+ *   Standalone SURNAME         → skip (too ambiguous)
+ */
+declare const detectNameCorpus: (fullText: string, ctx?: PipelineContext) => Entity[];
+//#endregion
+//#region src/unified-search.d.ts
+type UnifiedResult = {
+  /** All matches from both instances combined. */
+  regexMatches: Match[];
+  literalMatches: Match[];
+};
+declare const runUnifiedSearch: (instance: UnifiedSearchInstance, fullText: string) => UnifiedResult;
+//#endregion
+//#region src/regions.d.ts
+/**
+ * Geographic regions and country code mappings for
+ * scoping deny list dictionaries.
+ */
+declare const REGIONS: {
+  readonly Global: null;
+  readonly International: null;
+  readonly Europe: readonly ["AL", "AD", "AT", "BE", "BA", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IS", "IE", "IT", "XK", "LV", "LI", "LT", "LU", "MD", "ME", "MK", "MT", "MC", "NL", "NO", "PL", "PT", "RO", "RS", "SK", "SI", "ES", "SE", "CH", "UA", "GB"];
+  readonly Americas: readonly ["US", "CA", "MX", "BR", "AR", "CL", "CO", "PE", "EC", "VE", "UY", "PY", "BO", "CR", "PA", "DO", "GT", "HN", "SV", "NI", "CU"];
+  readonly AsiaPacific: readonly ["AU", "NZ", "JP", "KR", "CN", "TW", "SG", "MY", "TH", "VN", "PH", "ID", "IN", "PK", "BD", "LK", "NP", "HK", "MO"];
+  readonly MENA: readonly ["AE", "SA", "IL", "TR", "EG", "JO", "LB", "IQ", "IR", "QA", "KW", "BH", "OM", "MA", "TN", "DZ", "LY", "SY", "YE", "PS"];
+  readonly SubSaharanAfrica: readonly ["ZA", "NG", "KE", "GH", "TZ", "ET", "SN", "CI", "CM", "UG", "RW", "MZ", "AO", "ZW", "BW", "NA", "MU"];
+  readonly EU: readonly ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE"];
+  readonly DACH: readonly ["DE", "AT", "CH"];
+  readonly Nordics: readonly ["DK", "SE", "NO", "FI", "IS"];
+  readonly CEE: readonly ["CZ", "SK", "PL", "HU", "RO", "BG", "HR", "SI", "LT", "LV", "EE"];
+  readonly Anglosphere: readonly ["GB", "US", "CA", "AU", "NZ", "IE"];
+  readonly Benelux: readonly ["BE", "NL", "LU"];
+  readonly GulfStates: readonly ["AE", "SA", "QA", "KW", "BH", "OM"];
+  readonly SouthAsia: readonly ["IN", "PK", "BD", "LK", "NP"];
+  readonly EastAsia: readonly ["CN", "JP", "KR", "TW"];
+  readonly SoutheastAsia: readonly ["SG", "MY", "TH", "VN", "PH", "ID"];
+  readonly Oceania: readonly ["AU", "NZ"];
+};
+type RegionId = keyof typeof REGIONS;
+type RegionArrays = { [K in RegionId]: (typeof REGIONS)[K] };
+type NonNullRegion = { [K in RegionId as RegionArrays[K] extends null ? never : K]: RegionArrays[K] };
+type CountryCode = NonNullRegion[keyof NonNullRegion][number];
+/**
+ * Expand region names to country codes and merge with
+ * explicit country codes. Returns null when both inputs
+ * are empty/undefined (meaning "match all countries").
+ */
+declare const resolveCountries: (regions?: string[], countries?: string[]) => Set<string> | null;
+//#endregion
+//#region src/filters/false-positives.d.ts
+/**
+ * Filter out entities that are likely false positives:
+ * template placeholders, clause/section numbers,
+ * standalone years, and generic legal role terms.
+ *
+ * Runs as a post-processing step after all detection
+ * layers have merged.
+ */
+declare const filterFalsePositives: (entities: Entity[], ctx?: PipelineContext) => Entity[];
+//#endregion
+//#region src/filters/confidence-boost.d.ts
+/**
+ * Boost confidence of near-miss NER entities that appear
+ * near high-confidence detections (regex, trigger phrase).
+ *
+ * If an NER entity scored between (threshold - 0.15) and
+ * threshold, count how many confirmed entities exist within
+ * a 150-char window. Add +0.05 per co-located entity.
+ * If the boosted score crosses the threshold, include it.
+ *
+ * Only mutates score on near-miss entities; high-confidence
+ * entities pass through unchanged.
+ */
+declare const boostNearMissEntities: (entities: Entity[], threshold: number) => Entity[];
+/** Ensure preposition data is loaded. */
+//#endregion
+//#region src/filters/hotword-rules.d.ts
+type HotwordRule = {
+  hotwords: string[];
+  targetLabels: string[];
+  scoreAdjustment: number;
+  reclassifyTo?: string;
+  proximityBefore: number;
+  proximityAfter: number;
+};
+/**
+ * Load hotword rules from the data package.
+ * Safe to call multiple times; subsequent calls
+ * are no-ops.
+ */
+declare const initHotwordRules: () => Promise<void>;
+/**
+ * Apply hotword context rules to detected entities.
+ *
+ * Scans `fullText` once with a single AC automaton
+ * for all hotwords across all rules, then checks
+ * proximity to each entity. Distance-decayed
+ * adjustment: closer hotwords give a stronger boost.
+ *
+ * Returns a new array; input entities are not mutated.
+ */
+declare const applyHotwordRules: (entities: Entity[], fullText: string) => Entity[];
+//#endregion
+//#region src/filters/zone-classifier.d.ts
+type DocumentZone = "header" | "signature" | "body" | "table";
+type ZoneSpan = {
+  zone: DocumentZone;
+  start: number;
+  end: number;
+};
+/**
+ * Additive score adjustments per document zone.
+ * Header and signature blocks are dense with PII;
+ * tables often contain structured identifying data.
+ */
+declare const ZONE_SCORE_ADJUSTMENTS: {
+  readonly header: 0.1;
+  readonly signature: 0.15;
+  readonly body: 0;
+  readonly table: 0.05;
+};
+/**
+ * Ensure config data is loaded. Call once before
+ * classifyZones. Safe to call multiple times.
+ */
+declare const initZoneClassifier: (ctx?: PipelineContext) => Promise<void>;
+/**
+ * Classify a document into zones based on
+ * structural heuristics. Zones are non-overlapping
+ * and cover the entire text.
+ *
+ * Must call `initZoneClassifier()` first.
+ */
+declare const classifyZones: (fullText: string, ctx?: PipelineContext) => ZoneSpan[];
+/**
+ * Apply zone-based score adjustments to entities.
+ * Entities in header/signature/table zones get a
+ * small additive boost reflecting the higher PII
+ * density in those regions.
+ *
+ * Returns a new array; does not mutate inputs.
+ */
+declare const applyZoneAdjustments: (entities: Entity[], zones: ZoneSpan[]) => Entity[];
+//#endregion
+//#region src/gliner/types.d.ts
+/**
+ * GLiNER inference types.
+ *
+ * Forked from gliner@0.0.19 (MIT), stripped to runtime-
+ * agnostic core. Original: github.com/Ingvarstep/GLiNER.js
+ */
+type EntityResult = {
+  spanText: string;
+  start: number;
+  end: number;
+  label: string;
+  score: number;
+};
+/**
+ * Raw inference output: per-batch array of
+ * [spanText, start, end, label, score] tuples.
+ */
+type RawInferenceResult = [string, number, number, string, number][][];
+//#endregion
+//#region src/gliner/decoder.d.ts
+/**
+ * Decode span-level model logits into entity results.
+ */
+declare const decodeSpans: (batchSize: number, inputLength: number, maxWidth: number, numEntities: number, texts: string[], batchIds: number[], batchWordsStartIdx: number[][], batchWordsEndIdx: number[][], idToClass: Record<number, string>, modelOutput: ArrayLike<number>, flatNer: boolean, threshold: number, multiLabel: boolean) => RawInferenceResult;
+//#endregion
+//#region src/gliner/token-decoder.d.ts
+/**
+ * Decode token-level BIO logits into entity spans.
+ *
+ * For each word, checks if the B(egin) logit for any class
+ * exceeds the threshold. If so, extends the span by consuming
+ * subsequent I(nside) tokens of the same class.
+ */
+declare const decodeTokenSpans: (batchSize: number, numWords: number, numEntities: number, texts: string[], batchIds: number[], batchWordsStartIdx: number[][], batchWordsEndIdx: number[][], idToClass: Record<number, string>, modelOutput: ArrayLike<number>, threshold: number) => RawInferenceResult;
+//#endregion
+//#region src/gliner/processor.d.ts
+/** Tokenize text into words with character offsets. */
+declare const tokenizeText: (text: string) => [words: string[], starts: number[], ends: number[]];
+/** Pad a 2D or 3D array to uniform inner length. */
+
+/** Prepare a complete batch for ONNX inference. */
+declare const prepareBatch: (tokenizer: Tokenizer, texts: string[], entities: string[], maxWidth: number) => {
+  inputsIds: number[][];
+  attentionMasks: number[][];
+  wordsMasks: number[][];
+  textLengths: number[];
+  spanIdxs: number[][][];
+  spanMasks: boolean[][];
+  idToClass: Record<number, string>;
+  batchTokens: string[][];
+  batchWordsStartIdx: number[][];
+  batchWordsEndIdx: number[][];
+};
+//#endregion
+//#region src/util/chunker.d.ts
+/**
+ * Split text into overlapping chunks for GLiNER's
+ * ~512 token context window. Character-based splitting
+ * (rough approximation of token limits).
+ *
+ * Tries to break at sentence boundaries when possible.
+ */
+declare const chunkText: (text: string) => string[];
+/**
+ * Compute the byte offset of each chunk within the
+ * original document text.
+ */
+declare const computeChunkOffsets: (fullText: string, chunks: string[]) => number[];
+/**
+ * Merge entities from overlapping chunks back to
+ * document-level offsets. Deduplicates entities that
+ * appear in overlap regions (keeps highest score).
+ *
+ * Dedup invariant: each incoming entity is compared
+ * against the highest-scored same-label near-dup in
+ * its proximity window. If it loses, it is dropped.
+ * This does NOT guarantee that all pairwise near-dup
+ * relationships in the output are resolved; a lower-
+ * scored entity can survive if the bridging entity
+ * that would have replaced it was itself dropped by
+ * a higher-scored match.
+ *
+ * Uses a reverse-scan over the sorted merged array
+ * so each entity only compares against nearby
+ * predecessors — O(n * w) average where w is the max
+ * entities per POSITION_THRESHOLD window, O(n²) worst
+ * case when replacements dominate (splice is O(n)).
+ */
+declare const mergeChunkEntities: (chunkOffsets: number[], chunkResults: Entity[][]) => Entity[];
+//#endregion
+//#region src/util/levenshtein.d.ts
+/**
+ * Compute the Levenshtein edit distance between two
+ * strings. O(n*m) time, O(min(n,m)) space using a
+ * single-row DP approach.
+ */
+declare const levenshtein: (rawA: string, rawB: string) => number;
+//#endregion
+//#region src/util/normalize.d.ts
+/**
+ * Normalize typographic variants for search matching.
+ *
+ * Legal documents (especially Czech/German) use
+ * non-breaking spaces, smart quotes, and en/em dashes
+ * that differ from their ASCII equivalents. Since all
+ * replacements are same-length (single code unit →
+ * single code unit), character offsets remain valid.
+ *
+ * Lives here (application layer) rather than in the
+ * AC library: what to normalize is domain-specific.
+ *
+ * Uses a char-code lookup (`Map<number, number>`) and
+ * `Uint16Array` instead of 7 sequential `replaceAll`
+ * calls. For a 50 KB document this eliminates ~350 KB
+ * of intermediate string allocations.
+ *
+ * When no replaceable characters are present (common
+ * for plain-text inputs), a fast-path scan returns the
+ * original string without any allocation. When special
+ * characters exist, the string is scanned twice: once
+ * to detect, once to build the replacement array.
+ */
+declare const normalizeForSearch: (text: string) => string;
+//#endregion
+export { type AnonymisationOperator, CURRENCY_PATTERN_META, type CountryCode, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, type DefinitionPattern, type DenyListCategory, type DenyListData, type DetectionSource, type DocumentZone, type Entity, type EntityResult, type GazetteerData, type GazetteerEntry, type HotwordRule, type NameCorpusData, type NerInferenceFn, OPERATOR_REGISTRY, OPERATOR_TYPES, type OperatorConfig, type OperatorType, type PipelineConfig, type PipelineContext, type PipelineOptions, REGEX_META, REGEX_PATTERNS, REGIONS, type RawInferenceResult, type RedactionResult, type RegexMeta, type RegionId, type ReviewDecision, type ReviewedEntity, type TriggerExtension, type TriggerGroupConfig, type TriggerRule, type TriggerStrategy, type TriggerValidation, type UnifiedResult, type UnifiedSearchInstance, ZONE_SCORE_ADJUSTMENTS, type ZoneSpan, applyHotwordRules, applyZoneAdjustments, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText };
+//# sourceMappingURL=index.d.ts.map