@stll/anonymize-wasm 2.0.0-alpha.1 → 2.0.1

package/dist/wasm.d.mts

@@ -1,625 +1,18 @@
 import { a as OPERATOR_TYPES, i as DetectionSource, n as DETECTION_SOURCES, o as OperatorType, r as DETECTOR_PRIORITY, t as DEFAULT_ENTITY_LABELS } from "./constants2.mjs";
-import { Validator } from "@stll/stdnum";
-import { Match, PatternEntry, TextSearch } from "@stll/text-search";
-import { Tokenizer } from "@huggingface/tokenizers";
 
-//#region src/types.d.ts
-/**
- * Fields shared by every entity span in the source text.
- */
-type EntityBase = {
-  start: number;
-  end: number;
-  label: string;
-  text: string;
-  score: number;
-  sourceDetail?: "custom-deny-list" | "custom-regex" | "gazetteer-extension";
-};
-/**
- * A PII entity span found by a primary detection layer
- * (regex, NER, legal forms, deny list, ...).
- */
-type DetectedEntity = EntityBase & {
-  source: Exclude<DetectionSource, typeof DETECTION_SOURCES.COREFERENCE>;
-};
-/**
- * An alias mention of a previously detected entity: a
- * defined term ("the Seller") or a propagated bare
- * mention ("Acme" after "Acme Corp.").
- *
- * `corefSourceText` is required by construction, so an
- * alias cannot exist without the link back to its source
- * entity. Placeholder numbering reads it to give the
- * alias the same placeholder as the source. The link
- * travels with the entity instead of living in a
- * side-channel map that a producer could forget to
- * write — or that a later pass could clear.
- */
-type CorefAliasEntity = EntityBase & {
-  source: typeof DETECTION_SOURCES.COREFERENCE; /** Full text of the source entity this alias refers to. */
-  corefSourceText: string;
-};
-/**
- * A detected PII entity span in the source text.
- * Every detection layer produces these.
- */
-type Entity = DetectedEntity | CorefAliasEntity;
-/**
- * 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";
-  /**
-   * Optional list of lowercase keywords that terminate
-   * the value scan, in addition to commas/newlines. Useful
-   * for triggers like court names that may continue past
-   * a missing comma into adjacent clause text ("Městským
-   * soudem v Praze dne 1. 1. 2020"); listing `"dne"` here
-   * stops the scan at the date boundary. Matched on a
-   * word-boundary, case-insensitive.
-   */
-  stopWords?: string[];
-  /**
-   * Hard cap on the captured span length, in characters,
-   * regardless of where the next comma / stop char sits.
-   * Use for triggers that label short formulaic phrases
-   * ("State of Delaware") and must not absorb the rest
-   * of a long forum-selection clause when the comma is
-   * sentences away. Falls back to the default 100-char
-   * fallback when omitted.
-   */
-  maxLength?: number;
-} | {
-  type: "to-end-of-line";
-} | {
-  type: "n-words";
-  count: number;
-} | {
-  type: "company-id-value";
-} | {
-  type: "address";
-  maxChars?: number;
-} | {
-  /**
-   * Extract the first regex match in the value text.
-   * Useful for shape-bounded values that follow a
-   * label on the same line as other fields, where
-   * `to-end-of-line` would over-capture. The pattern
-   * is anchored to the start of the (already
-   * leading-whitespace-stripped) value, so use
-   * `(?:.*?)` prefix only when intentional.
-   */
-  type: "match-pattern";
-  pattern: string;
-  flags?: string;
-};
-/** 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;
-}
-/**
- * Run a named stdnum validator (checksum + length)
- * against the captured value. Keeps the trigger
- * path symmetrical with the formatted-regex
- * detectors so e.g. `CPF nº 00000000000` does not
- * survive as a tax-ID entity.
- */
-| {
-  type: "valid-id";
-  validator: ValidIdValidator;
-};
-/** Built-in stdnum validators that can be referenced
- *  by `valid-id` validations. */
-type ValidIdValidator = "br.cpf" | "br.cnpj" | "us.rtn";
-/** 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;
-} | {
-  type: "valid-id";
-  validator: ValidIdValidator;
-  check: (value: string) => boolean;
-};
-/**
- * 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;
-};
-/** 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";
-/**
- * Metadata for a single dictionary entry in the
- * deny-list system. Mirrors the shape from
- * the anonymize-data package so consumers can pass
- * pre-loaded data without a runtime dependency.
- */
-type DictionaryMeta = {
-  label: string;
-  category: DenyListCategory;
-  country: string | null;
-};
-/**
- * Caller-supplied exact terms for deny-list matching.
- * These entries are merged with the published deny-list
- * dictionaries when `enableDenyList` is enabled.
- */
-type CustomDenyListEntry = {
-  value: string;
-  label: string;
-  variants?: readonly string[];
-};
-/**
- * Caller-supplied regex detector. The pattern is passed
- * to the underlying text-search regex engine, so use its
- * supported regex syntax. Inline flags such as `(?i)` are
- * accepted when supported by that engine.
- */
-type CustomRegexPattern = {
-  pattern: string;
-  label: string;
-  score?: number;
-  preparedArtifactPolicy?: "include" | "omit";
-};
-/**
- * Pre-loaded dictionary data for dependency injection.
- * Consumers that want name/city/deny-list detection
- * load dictionaries themselves (e.g. from the
- * anonymize-data package) and pass them here; the
- * anonymize package has zero cross-package imports.
- *
- * All fields are optional. When a field is absent,
- * the corresponding detection path is skipped (same
- * behavior as when no dictionaries are available).
- */
-type Dictionaries = {
-  /**
-   * First names per language code (e.g., "cs", "de").
-   * Merged with legacy config names at init time.
-   */
-  firstNames?: Readonly<Record<string, readonly string[]>>;
-  /**
-   * Surnames per language code.
-   * Merged with legacy config names at init time.
-   */
-  surnames?: Readonly<Record<string, readonly string[]>>;
-  /**
-   * Non-Western name tokens per locale code
-   * (e.g., "in", "ar", "ja-latn", "ko", "zh-latn",
-   * "th", "vi", "fil", "id"). Merged with bundled
-   * names-nw-*.json data at init time.
-   */
-  nonWesternNames?: Readonly<Record<string, readonly string[]>>;
-  /**
-   * Pre-loaded deny-list dictionaries keyed by
-   * dictionary ID (e.g., "courts/CZ", "banks/DE").
-   * Each value is the array of terms for that
-   * dictionary.
-   */
-  denyList?: Readonly<Record<string, readonly string[]>>;
-  /**
-   * Metadata per dictionary ID. Required when
-   * `denyList` is provided so the pipeline knows
-   * labels, categories, and country filters.
-   */
-  denyListMeta?: Readonly<Record<string, DictionaryMeta>>;
-  /**
-   * Pre-loaded city names, already merged across
-   * all desired countries.
-   *
-   * Prefer `citiesByCountry` when callers also pass
-   * `denyListCountries` / `denyListRegions`; merged
-   * city arrays cannot be scoped after injection.
-   */
-  cities?: readonly string[];
-  /**
-   * Pre-loaded city names keyed by ISO 3166-1 alpha-2
-   * country code. When provided, the deny-list builder
-   * applies `denyListCountries` / `denyListRegions`
-   * before adding city patterns to the search automaton.
-   */
-  citiesByCountry?: Readonly<Record<string, readonly string[]>>;
-};
-type PipelineConfig = {
-  threshold: number;
-  enableTriggerPhrases: boolean;
-  enableRegex: boolean;
-  /**
-   * Expected content language codes. When present, these
-   * derive default dictionary scopes for name corpus and
-   * deny-list matching unless the lower-level scope fields
-   * below are set explicitly.
-   */
-  languages?: string[];
-  /**
-   * Convenience form for single-language documents. Ignored
-   * when `languages` is also provided.
-   */
-  language?: string;
-  /**
-   * Enables legal-form organization detection.
-   * Required for typed callers; legacy untyped
-   * callers that omit this field are treated as
-   * enabled at runtime for backward compatibility.
-   */
-  enableLegalForms: boolean;
-  /**
-   * Enables first-name/surname/title corpus matching.
-   * When deny-list mode is enabled, this also controls
-   * whether name-corpus entries are injected into the
-   * deny-list search automaton.
-   */
-  enableNameCorpus: boolean;
-  /**
-   * Optional language scope for first-name/surname
-   * dictionaries, using the keys present in
-   * `dictionaries.firstNames` / `dictionaries.surnames`
-   * (for example `["en", "de"]`). When omitted, all
-   * injected name languages are used for backward
-   * compatibility.
-   */
-  nameCorpusLanguages?: string[];
-  enableDenyList: boolean;
-  denyListCountries?: string[];
-  denyListRegions?: string[];
-  denyListExcludeCategories?: string[];
-  /**
-   * Caller-owned exact terms to match through the
-   * deny-list layer. Requires `enableDenyList: true`.
-   */
-  customDenyList?: readonly CustomDenyListEntry[];
-  /**
-   * Caller-owned regex detectors. Requires
-   * `enableRegex: true`.
-   */
-  customRegexes?: readonly CustomRegexPattern[];
-  enableGazetteer: boolean;
-  /**
-   * Detect country names (ISO 3166-1 names, curated
-   * aliases, alpha-3 codes). Defaults to true. Names
-   * span all manifest languages plus widely-used
-   * additions (Dutch, Russian, Chinese, Arabic, etc.).
-   */
-  enableCountries?: boolean;
-  enableNer: boolean;
-  enableConfidenceBoost: boolean;
-  enableCoreference: boolean;
-  enableZoneClassification?: boolean;
-  enableHotwordRules?: boolean;
-  /**
-   * Requested output labels. An empty array means
-   * "do not filter by label" for deterministic
-   * detectors; NER falls back to DEFAULT_ENTITY_LABELS.
-   */
-  labels: string[];
-  workspaceId: string;
-  /**
-   * Pre-loaded dictionary data for name, deny-list,
-   * and city detection. When omitted, dictionary-based
-   * detection paths are skipped. Consumers load from
-   * the anonymize-data package and pass the data here.
-   */
-  dictionaries?: Dictionaries;
-};
-//#endregion
-//#region src/detectors/regex.d.ts
-type RegexMeta = {
-  label: string;
-  score: number;
-  sourceDetail?: Entity["sourceDetail"];
-  minByteLength?: number; /** Post-match stdnum validator for confirmation. */
-  validator?: Validator;
-  validatorId?: string; /** Extract the identifier portion when context is part of the regex span. */
-  validatorInput?: (text: string) => string;
-  validatorInputKind?: "digits-only" | "crypto-wallet-candidate";
-};
-/** Flat pattern array for text-search. */
-declare const REGEX_PATTERNS: readonly string[];
-/** Parallel metadata. Index = pattern index. */
-declare const REGEX_META: readonly RegexMeta[];
-type DateMonthData = Record<string, string[]>;
-type YearWordData = Record<string, string[]>;
+//#region src/native-search-config.d.ts
 /**
- * Get dynamically built date patterns from
- * date-months.json. Returns a cached promise; the JSON
- * is loaded only once.
- */
-declare const getDatePatterns: (languages?: readonly string[]) => Promise<string[]>;
-/** Date pattern metadata (all are score 1 dates). */
-declare const DATE_PATTERN_META: Readonly<RegexMeta>;
-type MonetaryData = {
-  currencies: {
-    codes: string[];
-    symbols: string[];
-    local_names: string[];
-  };
-  amount_words: {
-    written_amount_patterns: Array<{
-      keywords: string[];
-    }>;
-    magnitude_suffixes: Array<{
-      words: string[];
-      abbreviations_case_insensitive: string[];
-      abbreviations_case_sensitive: string[];
-    }>;
-    share_quantity_terms: Array<{
-      modifiers: string[];
-      nouns: string[];
-    }>;
-  };
-};
-/**
- * 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.
+ * Structural type for the prepared static-search config the native binding
+ * consumes and the Rust assembler emits (`assembleStaticSearchConfigJson`).
  *
- * 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" | "enableNameCorpus" | "nameCorpusLanguages" | "denyListCountries" | "denyListRegions" | "denyListExcludeCategories" | "customDenyList" | "dictionaries" | "enableCountries">;
-type DenyListFilterData = {
-  stopwords: string[];
-  allowList: string[];
-  personStopwords: string[];
-  personTrailingNouns: string[];
-  addressStopwords: string[];
-  addressJurisdictionPrefixes: string[];
-  streetTypes: string[];
-  addressComponentTerms: string[];
-  ambiguousStreetTypeTerms: string[];
-  firstNames: string[];
-  genericRoles: string[];
-  numberAbbrevPrefixes: string[];
-  sentenceStarters: string[];
-  trailingAddressWordExclusions: string[];
-  documentHeadingWords: string[];
-  documentHeadingOrdinalMarkers: string[];
-  definedTermCues: string[];
-  signingPlaceGuards: DenyListSigningPlaceGuardData[];
-};
-type DenyListSigningPlaceGuardData = {
-  prefixPhrases: string[];
-  suffixPhrases: string[];
-};
-/**
- * Source tag for each pattern in the automaton.
- * "deny-list" = standard deny list entry
- * "city" = city dictionary entry
- * "custom-deny-list" = caller-owned exact term
- * "first-name" = name corpus first name
- * "surname" = name corpus surname
- * "title" = academic/professional title
- */
-type PatternSource = "deny-list" | "city" | "custom-deny-list" | "first-name" | "surname" | "title";
-type PatternLabels = string | string[];
-type PatternSources = PatternSource | PatternSource[];
-/**
- * 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.
+ * This config used to be built in TypeScript by `build-unified-search.ts`; that
+ * layer was retired in favor of the Rust assembler
+ * (`crates/anonymize-adapter-contract` `assemble_static_search_config`). The
+ * type now lives here as a pure, dependency-free description of the JSON the
+ * binding accepts on its `fromConfigJsonBytes` / prepare paths, so callers that
+ * hold a pre-assembled config keep a precise type without pulling in the
+ * deleted detector modules.
  */
-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: PatternLabels[]; /** Maps pattern index → labels contributed by custom entries. */
-  customLabels: (PatternLabels | undefined)[]; /** Maps pattern index → original pattern text. */
-  originals: string[]; /** Maps pattern index → source types (plural). */
-  sources: PatternSources[];
-  filters: DenyListFilterData;
-};
-/**
- * Resolve which dictionaries to load based on country
- * and category filters, then build the deny list data.
- * The returned data provides PatternEntry[] for the
- * unified builder and parallel arrays for
- * post-processing.
- *
- * Dictionary data is injected via `config.dictionaries`.
- * Returns null if no dictionaries are provided.
- */
-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, dictionaries?: Dictionaries, nameCorpusLanguages?: readonly string[]) => 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/detectors/address-seeds.d.ts
-type AddressSeedData = {
-  boundary_words: string[];
-  br_cep_cue_words: string[];
-  unit_abbreviations: string[];
-};
-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/countries.d.ts
-/**
- * Pre-built country patterns + parallel label/source
- * metadata. Constructed once and reused across pipeline
- * runs.
- */
-type CountryData = {
-  /** Maps local pattern index to entity label. Always "country". */labels: string[];
-  /**
-   * Maps local pattern index to the alpha-2 ISO code the
-   * pattern resolves to. Used for downstream coreference /
-   * placeholder grouping.
-   */
-  isoCodes: string[]; /** Maps local pattern index to pattern variant kind. */
-  variants: CountryVariant[];
-};
-type CountryVariant = "name" | "alias" | "alpha3" | "alpha2";
-//#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[];
-type AddressContextData = {
-  address_prepositions: string[];
-  temporal_prepositions: string[];
-  street_abbreviations: string[];
-  bare_house_stopwords: string[];
-};
-//#endregion
-//#region src/build-unified-search.d.ts
 type PatternSlice = {
   start: number;
   end: number;
@@ -657,6 +50,10 @@ type NativeRegexMatchMeta = {
   validator_input?: string;
   min_byte_length?: number;
 };
+type NativeSigningPlaceGuardData = {
+  prefix_phrases: string[];
+  suffix_phrases: string[];
+};
 type NativeDenyListFilterData = {
   stopwords: string[];
   allow_list: string[];
@@ -677,10 +74,6 @@ type NativeDenyListFilterData = {
   defined_term_cues: string[];
   signing_place_guards: NativeSigningPlaceGuardData[];
 };
-type NativeSigningPlaceGuardData = {
-  prefix_phrases: string[];
-  suffix_phrases: string[];
-};
 type NativeDenyListMatchData = {
   labels?: string[][];
   label_table?: string[];
@@ -767,13 +160,44 @@ type NativeLegalFormData = {
   company_suffix_words: string[];
   comma_gated_direct_prefixes: string[];
 };
+type NativeDateMonthData = Record<string, string[]>;
+type NativeYearWordData = Record<string, string[]>;
 type NativeDateData = {
-  month_names_by_language: DateMonthData;
-  year_words_by_language: YearWordData;
+  month_names_by_language: NativeDateMonthData;
+  year_words_by_language: NativeYearWordData;
+};
+type NativeMonetaryData = {
+  currencies: {
+    codes: string[];
+    symbols: string[];
+    local_names: string[];
+  };
+  amount_words: {
+    written_amount_patterns: Array<{
+      keywords: string[];
+    }>;
+    magnitude_suffixes: Array<{
+      words: string[];
+      abbreviations_case_insensitive: string[];
+      abbreviations_case_sensitive: string[];
+    }>;
+    share_quantity_terms: Array<{
+      modifiers: string[];
+      nouns: string[];
+    }>;
+  };
+};
+type NativeAddressSeedData = {
+  boundary_words: string[];
+  br_cep_cue_words: string[];
+  unit_abbreviations: string[];
+};
+type NativeAddressContextData = {
+  address_prepositions: string[];
+  temporal_prepositions: string[];
+  street_abbreviations: string[];
+  bare_house_stopwords: string[];
 };
-type NativeMonetaryData = MonetaryData;
-type NativeAddressSeedData = AddressSeedData;
-type NativeAddressContextData = AddressContextData;
 type NativeCoreferencePatternData = {
   pattern: string;
   flags: string;
@@ -816,6 +240,11 @@ type NativeZoneData = {
   section_heading_patterns: NativeZonePatternData[];
   signing_clauses: NativeZoneSigningClauseData[];
 };
+type NativeCountryData = {
+  labels: string[];
+  isoCodes: string[];
+  variants: Array<"name" | "alias" | "alpha3" | "alpha2">;
+};
 type NativeGazetteerData = {
   labels: string[];
   is_fuzzy: boolean[];
@@ -867,7 +296,7 @@ type NativePreparedSearchConfig = {
   deny_list_data?: NativeDenyListMatchData;
   false_positive_filters?: NativeDenyListFilterData;
   gazetteer_data?: NativeGazetteerData;
-  country_data?: CountryData;
+  country_data?: NativeCountryData;
   hotword_data?: NativeHotwordRuleData;
   trigger_data?: NativeTriggerData;
   legal_form_data?: NativeLegalFormData;
@@ -881,188 +310,276 @@ type NativePreparedSearchConfig = {
   date_data?: NativeDateData;
   monetary_data?: NativeMonetaryData;
 };
-type GazetteerData = {
-  /** Maps local pattern index to entry label. */labels: string[];
+//#endregion
+//#region src/types.d.ts
+/**
+ * Fields shared by every entity span in the source text.
+ */
+type EntityBase = {
+  start: number;
+  end: number;
+  label: string;
+  text: string;
+  score: number;
+  sourceDetail?: "custom-deny-list" | "custom-regex" | "gazetteer-extension";
+};
+/**
+ * A PII entity span found by a primary detection layer
+ * (regex, NER, legal forms, deny list, ...).
+ */
+type DetectedEntity = EntityBase & {
+  source: Exclude<DetectionSource, typeof DETECTION_SOURCES.COREFERENCE>;
+};
+/**
+ * An alias mention of a previously detected entity: a
+ * defined term ("the Seller") or a propagated bare
+ * mention ("Acme" after "Acme Corp.").
+ *
+ * `corefSourceText` is required by construction, so an
+ * alias cannot exist without the link back to its source
+ * entity. Placeholder numbering reads it to give the
+ * alias the same placeholder as the source. The link
+ * travels with the entity instead of living in a
+ * side-channel map that a producer could forget to
+ * write — or that a later pass could clear.
+ */
+type CorefAliasEntity = EntityBase & {
+  source: typeof DETECTION_SOURCES.COREFERENCE; /** Full text of the source entity this alias refers to. */
+  corefSourceText: string;
+};
+/**
+ * A detected PII entity span in the source text.
+ * Every detection layer produces these.
+ */
+type Entity = DetectedEntity | CorefAliasEntity;
+/**
+ * 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";
+};
+/** 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";
+/**
+ * Metadata for a single dictionary entry in the
+ * deny-list system. Mirrors the shape from
+ * the anonymize-data package so consumers can pass
+ * pre-loaded data without a runtime dependency.
+ */
+type DictionaryMeta = {
+  label: string;
+  category: DenyListCategory;
+  country: string | null;
+};
+/**
+ * Caller-supplied exact terms for deny-list matching.
+ * These entries are merged with the published deny-list
+ * dictionaries when `enableDenyList` is enabled.
+ */
+type CustomDenyListEntry = {
+  value: string;
+  label: string;
+  variants?: readonly string[];
+};
+/**
+ * Caller-supplied regex detector. The pattern is passed
+ * to the underlying text-search regex engine, so use its
+ * supported regex syntax. Inline flags such as `(?i)` are
+ * accepted when supported by that engine.
+ */
+type CustomRegexPattern = {
+  pattern: string;
+  label: string;
+  score?: number;
+  preparedArtifactPolicy?: "include" | "omit";
+};
+/**
+ * Pre-loaded dictionary data for dependency injection.
+ * Consumers that want name/city/deny-list detection
+ * load dictionaries themselves (e.g. from the
+ * anonymize-data package) and pass them here; the
+ * anonymize package has zero cross-package imports.
+ *
+ * All fields are optional. When a field is absent,
+ * the corresponding detection path is skipped (same
+ * behavior as when no dictionaries are available).
+ */
+type Dictionaries = {
+  /**
+   * First names per language code (e.g., "cs", "de").
+   * Merged with legacy config names at init time.
+   */
+  firstNames?: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Surnames per language code.
+   * Merged with legacy config names at init time.
+   */
+  surnames?: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Non-Western name tokens per locale code
+   * (e.g., "in", "ar", "ja-latn", "ko", "zh-latn",
+   * "th", "vi", "fil", "id"). Merged with bundled
+   * names-nw-*.json data at init time.
+   */
+  nonWesternNames?: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Pre-loaded deny-list dictionaries keyed by
+   * dictionary ID (e.g., "courts/CZ", "banks/DE").
+   * Each value is the array of terms for that
+   * dictionary.
+   */
+  denyList?: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Metadata per dictionary ID. Required when
+   * `denyList` is provided so the pipeline knows
+   * labels, categories, and country filters.
+   */
+  denyListMeta?: Readonly<Record<string, DictionaryMeta>>;
+  /**
+   * Pre-loaded city names, already merged across
+   * all desired countries.
+   *
+   * Prefer `citiesByCountry` when callers also pass
+   * `denyListCountries` / `denyListRegions`; merged
+   * city arrays cannot be scoped after injection.
+   */
+  cities?: readonly string[];
+  /**
+   * Pre-loaded city names keyed by ISO 3166-1 alpha-2
+   * country code. When provided, the deny-list builder
+   * applies `denyListCountries` / `denyListRegions`
+   * before adding city patterns to the search automaton.
+   */
+  citiesByCountry?: Readonly<Record<string, readonly string[]>>;
+};
+type PipelineConfig = {
+  threshold: number;
+  enableTriggerPhrases: boolean;
+  enableRegex: boolean;
+  /**
+   * Expected content language codes. When present, these
+   * derive default dictionary scopes for name corpus and
+   * deny-list matching unless the lower-level scope fields
+   * below are set explicitly.
+   */
+  languages?: string[];
+  /**
+   * Convenience form for single-language documents. Ignored
+   * when `languages` is also provided.
+   */
+  language?: string;
+  /**
+   * Enables legal-form organization detection.
+   * Required for typed callers; legacy untyped
+   * callers that omit this field are treated as
+   * enabled at runtime for backward compatibility.
+   */
+  enableLegalForms: boolean;
+  /**
+   * Enables first-name/surname/title corpus matching.
+   * When deny-list mode is enabled, this also controls
+   * whether name-corpus entries are injected into the
+   * deny-list search automaton.
+   */
+  enableNameCorpus: boolean;
+  /**
+   * Optional language scope for first-name/surname
+   * dictionaries, using the keys present in
+   * `dictionaries.firstNames` / `dictionaries.surnames`
+   * (for example `["en", "de"]`). When omitted, all
+   * injected name languages are used for backward
+   * compatibility.
+   */
+  nameCorpusLanguages?: string[];
+  enableDenyList: boolean;
+  denyListCountries?: string[];
+  denyListRegions?: string[];
+  denyListExcludeCategories?: string[];
+  /**
+   * Caller-owned exact terms to match through the
+   * deny-list layer. Requires `enableDenyList: true`.
+   */
+  customDenyList?: readonly CustomDenyListEntry[];
+  /**
+   * Caller-owned regex detectors. Requires
+   * `enableRegex: true`.
+   */
+  customRegexes?: readonly CustomRegexPattern[];
+  enableGazetteer: boolean;
+  /**
+   * Detect country names (ISO 3166-1 names, curated
+   * aliases, alpha-3 codes). Defaults to true. Names
+   * span all manifest languages plus widely-used
+   * additions (Dutch, Russian, Chinese, Arabic, etc.).
+   */
+  enableCountries?: boolean;
+  enableNer: boolean;
+  enableConfidenceBoost: boolean;
+  enableCoreference: boolean;
+  enableZoneClassification?: boolean;
+  enableHotwordRules?: boolean;
   /**
-   * Whether each pattern is fuzzy (distance > 0).
-   * Used by the post-processor to assign scores.
+   * Requested output labels. An empty array means
+   * "do not filter by label" for deterministic
+   * detectors; NER falls back to DEFAULT_ENTITY_LABELS.
    */
-  isFuzzy: boolean[];
-};
-type UnifiedSearchInstance = {
-  /** Regex + triggers + legal-forms. */tsRegex: TextSearch; /** Caller-owned custom regexes, isolated for overlap preservation. */
-  tsCustomRegex: TextSearch; /** Deny-list + street-types + gazetteer. */
-  tsLiterals: TextSearch;
-  slices: {
-    regex: PatternSlice;
-    customRegex: PatternSlice;
-    legalForms: PatternSlice;
-    triggers: PatternSlice;
-    denyList: PatternSlice;
-    streetTypes: PatternSlice;
-    gazetteer: PatternSlice;
-    countries: PatternSlice;
-  };
-  regexMeta: readonly RegexMeta[];
-  customRegexMeta: readonly RegexMeta[];
-  triggerRules: readonly TriggerRule[];
-  denyListData: DenyListData | null;
-  gazetteerData: GazetteerData | null;
-  countryData: CountryData | null;
-  nativeStaticConfig: NativePreparedSearchConfig;
-};
-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.
- *
- * @deprecated No longer used internally: coref alias
- *   links travel on the entities themselves
- *   (`corefSourceText`). Kept for API compatibility.
- */
-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>;
-  /** Abbreviation-style titles whose trailing dot is
-   *  part of the title, not a sentence boundary.
-   *  Contains the lowercase, dot-stripped form
-   *  (e.g., "dr", "smt", "atty"). */
-  titleAbbreviations: ReadonlySet<string>;
-  excludedWords: ReadonlySet<string>;
-  /** Lowercased common English words. A name chain whose
-   *  every token is a common word (e.g. "Loan Documents",
-   *  where "Loan" coincides with a Vietnamese given name)
-   *  is treated as a common-word phrase, not a person. */
-  commonWords: ReadonlySet<string>; /** Non-Western name tokens merged across all locales. */
-  nonWesternNames: ReadonlySet<string>; /** All-caps acronyms excluded from name detection. */
-  excludedAllCaps: ReadonlySet<string>; /** Raw arrays exposed for deny-list AC integration. */
-  firstNamesList: readonly string[];
-  surnamesList: readonly string[];
-  titlesList: readonly string[];
-  excludedList: readonly string[];
-  nonWesternNamesList: readonly string[];
-  excludedAllCapsList: 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;
-  nativePipelinePackage: Uint8Array | null;
-  nativePipelinePackageKey: string;
-  nativePipelinePackagePromise: Promise<Uint8Array> | null;
-  nameCorpus: NameCorpusData | null;
-  nameCorpusKey: string;
-  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;
-  definedTermHeads: ReadonlySet<string> | null;
-  definedTermHeadsPromise: Promise<ReadonlySet<string>> | null;
-  addressStopwords: ReadonlySet<string> | null;
-  addressStopwordsPromise: 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;
-  corefPatternsKey: string;
-  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;
-};
-/** Create a fresh, empty pipeline context. */
-declare const createPipelineContext: () => PipelineContext;
-//#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[]>;
-type PipelineSearchOptions = {
-  config: PipelineConfig;
-  gazetteerEntries?: GazetteerEntry[];
-  context?: PipelineContext;
-};
-/**
- * Pre-build and cache the unified search instance for a
- * pipeline configuration. Use the same context in
- * `runPipeline` to reuse the prepared automata without
- * passing `cachedSearch` around manually.
- */
-declare const preparePipelineSearch: ({
-  config,
-  gazetteerEntries,
-  context
-}: PipelineSearchOptions) => Promise<UnifiedSearchInstance>;
-/**
- * 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;
+  labels: string[];
+  workspaceId: string;
+  /**
+   * Pre-loaded dictionary data for name, deny-list,
+   * and city detection. When omitted, dictionary-based
+   * detection paths are skipped. Consumers load from
+   * the anonymize-data package and pass the data here.
+   */
+  dictionaries?: Dictionaries;
 };
-/**
- * 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/native.d.ts
 type NativeBindingOperatorConfig = {
@@ -1123,6 +640,9 @@ type NativeAnonymizeBinding = {
   };
   prepareStaticSearchPackageBytes: (configJson: Uint8Array) => Uint8Array;
   prepareStaticSearchCompressedPackageBytes: (configJson: Uint8Array) => Uint8Array;
+  assembleStaticSearchConfigJson?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
+  assembleStaticSearchPackageBytes?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
+  assembleStaticSearchCompressedPackageBytes?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
 };
 type NativeOperatorConfig = {
   operators?: Record<string, OperatorType>;
@@ -1170,6 +690,9 @@ type SharedNativeRedactTextJsonOptions = {
 };
 type SharedNativeRedactTextOptions = SharedNativeRedactTextJsonOptions;
 type SharedNativeDiagnosticsJsonOptions = SharedNativeRedactTextJsonOptions;
+type SharedNativeDiagnosticsStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
+  onBatch: NativeDiagnosticsBatchCallback;
+};
 type SharedNativeRedactTextStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
   onEvent: NativeResultEventCallback;
 };
@@ -1237,11 +760,6 @@ declare class PreparedNativePipeline {
 declare const encodeNativeSearchConfig: (config: NativePreparedSearchConfig) => Uint8Array;
 declare const encodeNativeSearchConfigInput: (config: NativeSearchPackageInput) => Uint8Array;
 declare const getNativeBindingVersion: (binding: NativeAnonymizeBinding) => string;
-declare const native_package_version: (binding: NativeAnonymizeBinding) => string;
-declare const normalize_for_search: ({
-  binding,
-  text
-}: NativeNormalizeOptions) => string;
 declare const assertNativeBindingVersion: ({
   binding,
   expectedVersion
@@ -1251,11 +769,6 @@ declare const prepareNativeSearchPackage: ({
   config,
   compressed
 }: NativeSearchPackageOptions) => Uint8Array;
-declare const prepare_search_package: ({
-  binding,
-  config,
-  compressed
-}: SharedNativeSearchPackageOptions) => Uint8Array;
 declare const createNativeAnonymizerFromConfig: ({
   binding,
   config
@@ -1264,44 +777,43 @@ declare const createNativeAnonymizerFromPackage: ({
   binding,
   packageBytes
 }: NativeAnonymizerFromPackageOptions) => PreparedNativeAnonymizer;
-declare const load_prepared_package: ({
-  binding,
-  packageBytes
-}: SharedNativePreparedPackageOptions) => PreparedNativeAnonymizer;
-declare const redact_text_json: ({
-  binding,
-  config,
-  fullText,
-  operators
-}: SharedNativeRedactTextJsonOptions) => string;
-declare const redact_text: ({
-  binding,
-  config,
-  fullText,
-  operators
-}: SharedNativeRedactTextOptions) => NativeStaticRedactionResult;
-declare const redact_text_stream_json: ({
-  binding,
-  config,
-  fullText,
-  operators,
-  onEvent
-}: SharedNativeRedactTextStreamJsonOptions) => string | null;
-declare const diagnostics_json: ({
-  binding,
-  config,
-  fullText,
-  operators
-}: SharedNativeDiagnosticsJsonOptions) => string | null;
 declare const createNativePipelineFromPackage: ({
   binding,
   packageBytes
 }: NativePipelineFromPackageOptions) => PreparedNativePipeline;
 declare const PreparedSearch: typeof PreparedNativeAnonymizer;
 type PreparedSearch = PreparedNativeAnonymizer;
+declare const PreparedAnonymizer: typeof PreparedNativeAnonymizer;
+type PreparedAnonymizer = PreparedNativeAnonymizer;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Cached state for a single pipeline run (or a sequence of runs sharing the
+ * same config). The native pipeline builds its prepared package once and reuses
+ * it across calls with the same config; the package bytes and the key/promise
+ * that guard concurrent builds live here so callers can share one warmed
+ * context.
+ */
+type PipelineContext = {
+  nativePipelinePackage: Uint8Array | null;
+  nativePipelinePackageKey: string;
+  nativePipelinePackagePromise: Promise<Uint8Array> | null;
+};
+/** Create a fresh, empty pipeline context. */
+declare const createPipelineContext: () => PipelineContext;
 //#endregion
-//#region src/native-default-config.d.ts
-declare const DEFAULT_NATIVE_PIPELINE_CONFIG: PipelineConfig;
+//#region src/redact.d.ts
+/**
+ * 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/native-pipeline.d.ts
 type NativePipelineUnsupportedFeature = "enableNer";
@@ -1323,10 +835,10 @@ type NativePipelinePackageOptions = NativePipelineBuildOptions & {
 declare const getNativePipelineCompatibility: (config: PipelineConfig) => NativePipelineCompatibility;
 declare const assertNativePipelineSupported: (config: PipelineConfig) => void;
 declare const prepareNativePipelineConfig: ({
+  binding,
   config,
-  gazetteerEntries,
-  context
-}: Omit<NativePipelineBuildOptions, "binding">) => Promise<NativePreparedSearchConfig>;
+  gazetteerEntries
+}: Omit<NativePipelineBuildOptions, "context">) => Promise<NativePreparedSearchConfig>;
 declare const prepareNativePipelinePackage: ({
   binding,
   config,
@@ -1341,503 +853,60 @@ declare const createNativePipelineFromConfig: ({
   context
 }: NativePipelineBuildOptions) => Promise<PreparedNativePipeline>;
 //#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"
- * share one person placeholder).
- *
- * Placeholder format: [LABEL_N] where LABEL is uppercase.
- * N is allocated per label and skips tokens already present
- * in reserved text.
- *
- * @param _ctx Unused. Kept for signature compatibility;
- *   coref alias links now travel on the entities
- *   themselves (`corefSourceText`).
- */
-type PlaceholderMapOptions = {
-  reservedText?: string;
-};
-declare const buildPlaceholderMap: (entities: Entity[], _ctx?: PipelineContext, {
-  reservedText
-}?: PlaceholderMapOptions) => 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
-declare const warmLegalRoleHeads: () => Promise<void>;
-/**
- * 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.
- *
- * The role-head trimming step reads per-language data from
- * a cache that `runPipeline` warms via `warmLegalRoleHeads()`
- * before calling this. Callers that invoke
- * `processLegalFormMatches` directly (without going through
- * `runPipeline`) must `await warmLegalRoleHeads()` first;
- * otherwise the trim falls back to a no-op and sentence-
- * fragment fixes do not apply.
- */
-declare const processLegalFormMatches: (allMatches: Match[], sliceStart: number, sliceEnd: number, fullText?: string, options?: {
-  suppressExtendBackward?: boolean;
-}) => Entity[];
-//#endregion
-//#region src/detectors/triggers.d.ts
-type TriggerPatterns = {
-  patterns: string[];
-  rules: TriggerRule[];
-};
-declare const buildTriggerPatterns: (languages?: readonly string[]) => Promise<TriggerPatterns>;
-/**
- * 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/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 ExtractDefinedTermsOptions = {
-  languages?: readonly string[];
-};
-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, options?: ExtractDefinedTermsOptions) => 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).
- *
- * Each returned alias carries `corefSourceText` linking
- * it to its source entity text, for consistent
- * placeholder numbering.
- *
- * @param _ctx Unused. Kept for signature compatibility;
- *   alias links now travel on the entities themselves.
- */
-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.
- *
- * Propagated mentions are coref aliases: each carries
- * `corefSourceText` linking it to the full seed entity
- * text, so placeholder numbering assigns the bare
- * mention the same placeholder as its source ("Acme"
- * and "Acme Corp." both become [ORGANIZATION_1]).
- */
-declare const propagateOrgNames: (entities: Entity[], fullText: string) => Entity[];
-//#endregion
-//#region src/detectors/names.d.ts
-declare const getNameCorpusNonWesternNames: (ctx?: PipelineContext) => readonly string[];
-/**
- * Load name corpus data from injected dictionaries
- * and legacy config files. Merges all sources.
- *
- * Safe to call multiple times; only loads once per
- * context. Must be called before detectNameCorpus or
- * the getNameCorpus*() accessors are used.
- *
- * @param dictionaries Optional pre-loaded dictionaries
- *   with per-language first names and surnames. When
- *   omitted, only legacy config files are used.
- */
-declare const initNameCorpus: (ctx?: PipelineContext, dictionaries?: Dictionaries, languages?: readonly string[]) => Promise<void>;
-type NameCorpusDetectionOptions = {
-  mode?: "full" | "supplemental";
-};
-/**
- * Detect person names by looking up tokens against the
- * name corpus, then chaining adjacent name-like tokens.
- * Handles both Western and non-Western name patterns.
- *
- * Requires initNameCorpus() to have been called first.
- * If not initialized, returns an empty array.
- *
- * Scoring (Western):
- *   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)
- *
- * Scoring (non-Western, when chain contains nonWestern tokens):
- *   TITLE + (nonWestern|CAPITALIZED) → 0.95
- *   JA_SUFFIX + (CAPITALIZED|nonWestern) → 0.9
- *   ARABIC_CONNECTOR + nonWestern     → 0.9
- *   2+ nonWestern tokens              → 0.9
- *   nonWestern + (CAPITALIZED|ABBREVIATION) → 0.9
- *   Standalone nonWestern mid-sentence → 0.5
- */
-declare const detectNameCorpus: (fullText: string, ctx?: PipelineContext, options?: NameCorpusDetectionOptions) => Entity[];
-//#endregion
-//#region src/unified-search.d.ts
-type UnifiedResult = {
-  /** All matches from both instances combined. */regexMatches: Match[];
-  customRegexMatches: 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
-/** Ensure street-type vocabulary is loaded. */
-declare const initAddressComponents: () => Promise<void>;
-/**
- * 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, fullText?: string) => Entity[];
-//#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[]];
-/** 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
-/** A chunk paired with its start offset in the source text. */
-type ChunkSpan = {
-  text: string;
-  offset: number;
+//#region src/wasm.d.ts
+/** A prepared package the caller supplies: raw bytes, an ArrayBuffer, or a URL
+ * (string or `URL`) that resolves to the package and is fetched. */
+type PreparedPackageSource = Uint8Array | ArrayBuffer | URL | string;
+/** Escape hatch for callers that already hold a binding (e.g. a custom sidecar
+ * or a test double). When omitted, the lazily-instantiated wasm binding is
+ * used. */
+type WasmBindingOptions = {
+  binding?: NativeAnonymizeBinding;
+};
+/** Instantiate (once) and return the wasm binding. Safe to call repeatedly:
+ * the underlying wasm module is instantiated a single time and cached. */
+declare const getBinding: () => Promise<NativeAnonymizeBinding>;
+type LoadPreparedPackageOptions = WasmBindingOptions;
+/** Load a prepared package and return a pipeline ready to redact text. */
+declare const loadPipeline: (source: PreparedPackageSource, options?: LoadPreparedPackageOptions) => Promise<PreparedNativePipeline>;
+/** Load a prepared package and return the lower-level anonymizer. */
+declare const load_prepared_package: (source: PreparedPackageSource, options?: LoadPreparedPackageOptions) => Promise<PreparedNativeAnonymizer>;
+/** URL of a bundled default prepared package, resolved against this module so
+ * it points at the `native/` asset directory shipped in the tarball. */
+declare const defaultPackageUrl: (language?: string) => URL;
+/** Load a fresh pipeline from the bundled default prepared package.
+ *
+ * Mirrors the node loader's regional-tag fallback: when an exact package for
+ * a locale tag such as `en-US` is not shipped, the base-language package
+ * (`en`) is loaded instead. The browser cannot check asset existence up
+ * front, so the fallback triggers on a failed load of the exact package. */
+declare const loadDefaultPipeline: (language?: string, options?: LoadPreparedPackageOptions) => Promise<PreparedNativePipeline>;
+/** Cached variant of {@link loadDefaultPipeline}: the default pipeline for a
+ * given language is fetched and prepared once, then reused.
+ *
+ * Only the ambient-binding case is cached. The cache key is language-only, so a
+ * caller that injects its own `options.binding` bypasses the cache entirely:
+ * reusing a pipeline built against a different binding would be wrong, and
+ * folding the binding into the key would keep unbounded per-binding entries
+ * alive. Injected-binding callers get a fresh pipeline each call. */
+declare const getDefaultPipeline: (language?: string, options?: LoadPreparedPackageOptions) => Promise<PreparedNativePipeline>;
+declare const redactDefaultText: (fullText: string, operators?: NativeOperatorConfig, language?: string) => Promise<NativeStaticRedactionResult>;
+declare const redactDefaultTextJson: (fullText: string, operators?: NativeOperatorConfig, language?: string) => Promise<string>;
+declare const native_package_version: (options?: WasmBindingOptions) => Promise<string>;
+declare const normalize_for_search: (text: string, options?: WasmBindingOptions) => Promise<string>;
+type PrepareSearchPackageOptions = WasmBindingOptions & {
+  compressed?: boolean;
 };
-/**
- * Split text into overlapping chunks, each paired with its
- * exact start offset in the source text.
- *
- * Carrying the offset out of the splitter is the robust way to
- * map chunk-local entity offsets back to document offsets:
- * downstream code never has to re-locate a chunk by content
- * search (which mis-locates when boilerplate repeats; see
- * computeChunkOffsets).
- *
- * Character-based splitting (rough token approximation for
- * GLiNER's ~512 token window); breaks at sentence boundaries
- * when possible.
- */
-declare const chunkTextWithOffsets: (text: string) => ChunkSpan[];
-/**
- * Split text into overlapping chunks for GLiNER's ~512 token
- * context window. Character-based splitting (rough token
- * approximation); breaks at sentence boundaries when possible.
- *
- * Prefer chunkTextWithOffsets when you also need each chunk's
- * document offset.
- */
-declare const chunkText: (text: string) => string[];
-/**
- * Compute the start offset of each chunk within the original
- * document text by content search.
- *
- * @deprecated Re-locates each chunk with `indexOf`, which can
- *   match the wrong position when identical content repeats in
- *   the document (common in boilerplate-heavy legal text) and
- *   then desyncs every subsequent offset. Use
- *   `chunkTextWithOffsets`, which carries exact offsets out of
- *   the splitter.
- */
-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 ChunkSpan, type CountryCode, type CustomDenyListEntry, type CustomRegexPattern, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, DEFAULT_NATIVE_PIPELINE_CONFIG, DEFAULT_OPERATOR_CONFIG, DETECTION_SOURCES, DETECTOR_PRIORITY, type DefinitionPattern, type DenyListCategory, type DenyListData, type DetectionSource, type Dictionaries, type DictionaryMeta, type DocumentZone, type Entity, type EntityResult, type GazetteerData, type GazetteerEntry, type HotwordRule, type NameCorpusData, type NativeAnonymizeBinding, type NativeAnonymizerFromConfigOptions, type NativeAnonymizerFromPackageOptions, type NativeBindingVersionOptions, type NativeNormalizeOptions, type NativeOperatorConfig, type NativePipelineBuildOptions, type NativePipelineCompatibility, type NativePipelineEntity, type NativePipelineFromPackageOptions, type NativePipelinePackageOptions, type NativePipelineUnsupportedFeature, type NativePreparedSearchBinding, type NativeRedactionResult, type NativeResultEventCallback, type NativeSearchPackageInput, type NativeSearchPackageOptions, type NativeStaticRedactionResult, type NerInferenceFn, OPERATOR_REGISTRY, OPERATOR_TYPES, type OperatorConfig, type OperatorType, type PipelineConfig, type PipelineContext, type PipelineOptions, type PipelineSearchOptions, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedSearch, type PreparedSearch as PreparedSearchInstance, REGEX_META, REGEX_PATTERNS, REGIONS, type RawInferenceResult, type RedactionResult, type RegexMeta, type RegionId, type ReviewDecision, type ReviewedEntity, type SharedNativeDiagnosticsJsonOptions, type SharedNativePreparedPackageOptions, type SharedNativeRedactTextJsonOptions, type SharedNativeRedactTextOptions, type SharedNativeRedactTextStreamJsonOptions, type SharedNativeSearchPackageOptions, type TriggerExtension, type TriggerGroupConfig, type TriggerRule, type TriggerStrategy, type TriggerValidation, type UnifiedResult, type UnifiedSearchInstance, ZONE_SCORE_ADJUSTMENTS, type ZoneSpan, applyHotwordRules, applyZoneAdjustments, assertNativeBindingVersion, assertNativePipelineSupported, boostNearMissEntities, buildDenyList, buildGazetteerPatterns, buildLegalFormPatterns, buildPlaceholderMap, buildStreetTypePatterns, buildTriggerPatterns, buildUnifiedSearch, chunkText, chunkTextWithOffsets, classifyZones, computeChunkOffsets, corefKey, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromConfig, createNativePipelineFromPackage, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, diagnostics_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, getNameCorpusNonWesternNames, getNativeBindingVersion, getNativePipelineCompatibility, initAddressComponents, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, load_prepared_package, mergeAndDedup, mergeChunkEntities, native_package_version, normalizeForSearch, normalize_for_search, prepareBatch, prepareNativePipelineConfig, prepareNativePipelinePackage, prepareNativeSearchPackage, preparePipelineSearch, prepare_search_package, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, redact_text, redact_text_json, redact_text_stream_json, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText, warmLegalRoleHeads };
+declare const prepare_search_package: (config: NativeSearchPackageInput, {
+  compressed,
+  ...options
+}?: PrepareSearchPackageOptions) => Promise<Uint8Array>;
+declare const redact_text: (config: NativeSearchPackageInput, fullText: string, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<NativeStaticRedactionResult>;
+declare const redact_text_json: (config: NativeSearchPackageInput, fullText: string, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<string>;
+declare const redact_text_stream_json: (config: NativeSearchPackageInput, fullText: string, onEvent: NativeResultEventCallback, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<string | null>;
+declare const diagnostics_json: (config: NativeSearchPackageInput, fullText: string, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<string | null>;
+declare const diagnostics_stream_json: (config: NativeSearchPackageInput, fullText: string, onBatch: NativeDiagnosticsBatchCallback, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<string | null>;
+declare const summary_diagnostics_json: (config: NativeSearchPackageInput, fullText: string, operators?: NativeOperatorConfig, options?: WasmBindingOptions) => Promise<string | null>;
+//#endregion
+export { type AnonymisationOperator, DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, type DetectionSource, type Dictionaries, type Entity, type GazetteerEntry, LoadPreparedPackageOptions, NativeAnonymizeBinding, NativeAnonymizerFromConfigOptions, NativeAnonymizerFromPackageOptions, NativeBindingVersionOptions, NativeDiagnosticsBatchCallback, NativeNormalizeOptions, NativeOperatorConfig, type NativePipelineBuildOptions, type NativePipelineCompatibility, NativePipelineEntity, NativePipelineFromPackageOptions, type NativePipelinePackageOptions, type NativePipelineUnsupportedFeature, NativePreparedSearchBinding, type NativePreparedSearchConfig, NativeRedactionResult, NativeResultEventCallback, NativeSearchPackageInput, NativeSearchPackageOptions, NativeStaticRedactionResult, OPERATOR_TYPES, type OperatorConfig, type OperatorType, type PipelineConfig, type PipelineContext, PrepareSearchPackageOptions, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedPackageSource, PreparedSearch, type RedactionResult, type ReviewDecision, type ReviewedEntity, SharedNativeDiagnosticsJsonOptions, SharedNativeDiagnosticsStreamJsonOptions, SharedNativePreparedPackageOptions, SharedNativeRedactTextJsonOptions, SharedNativeRedactTextOptions, SharedNativeRedactTextStreamJsonOptions, SharedNativeSearchPackageOptions, WasmBindingOptions, assertNativeBindingVersion, assertNativePipelineSupported, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromConfig, createNativePipelineFromPackage, createPipelineContext, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, getNativePipelineCompatibility, loadDefaultPipeline, loadPipeline, load_prepared_package, native_package_version, normalize_for_search, prepareNativePipelineConfig, prepareNativePipelinePackage, prepareNativeSearchPackage, prepare_search_package, redactDefaultText, redactDefaultTextJson, redact_text, redact_text_json, redact_text_stream_json, summary_diagnostics_json };
 //# sourceMappingURL=wasm.d.mts.map