@stll/anonymize-wasm 1.5.0 → 2.0.0

package/dist/wasm.d.mts

@@ -1,8 +1,316 @@
 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/native-search-config.d.ts
+/**
+ * Structural type for the prepared static-search config the native binding
+ * consumes and the Rust assembler emits (`assembleStaticSearchConfigJson`).
+ *
+ * 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 PatternSlice = {
+  start: number;
+  end: number;
+};
+type NativeSearchPatternKind = "literal" | "literal-with-options" | "regex" | "fuzzy";
+type NativeSearchPattern = {
+  kind: NativeSearchPatternKind;
+  pattern: string;
+  distance?: number;
+  case_insensitive?: boolean;
+  whole_words?: boolean;
+  lazy?: boolean;
+  prefilter_any?: string[];
+  prefilter_case_insensitive?: boolean;
+  prefilter_regex?: string;
+  prefilter_window_bytes?: number;
+  prepared_artifact_policy?: "include" | "omit";
+};
+type NativeSearchOptions = {
+  literal_case_insensitive?: boolean;
+  literal_whole_words?: boolean;
+  regex_whole_words?: boolean;
+  regex_overlap_all?: boolean;
+  regex_artifact_policy?: "include" | "omit";
+  fuzzy_case_insensitive?: boolean;
+  fuzzy_whole_words?: boolean;
+  fuzzy_normalize_diacritics?: boolean;
+};
+type NativeRegexMatchMeta = {
+  label: string;
+  score: number;
+  source_detail?: string;
+  requires_validation?: boolean;
+  validator_id?: string;
+  validator_input?: string;
+  min_byte_length?: number;
+};
+type NativeSigningPlaceGuardData = {
+  prefix_phrases: string[];
+  suffix_phrases: string[];
+};
+type NativeDenyListFilterData = {
+  stopwords: string[];
+  allow_list: string[];
+  person_stopwords: string[];
+  person_trailing_nouns: string[];
+  address_stopwords: string[];
+  address_jurisdiction_prefixes: string[];
+  street_types: string[];
+  address_component_terms: string[];
+  ambiguous_street_type_terms: string[];
+  first_names: string[];
+  generic_roles: string[];
+  number_abbrev_prefixes: string[];
+  sentence_starters: string[];
+  trailing_address_word_exclusions: string[];
+  document_heading_words: string[];
+  document_heading_ordinal_markers: string[];
+  defined_term_cues: string[];
+  signing_place_guards: NativeSigningPlaceGuardData[];
+};
+type NativeDenyListMatchData = {
+  labels?: string[][];
+  label_table?: string[];
+  label_indices?: number[][];
+  custom_labels?: string[][];
+  custom_label_indices?: number[][];
+  originals: string[];
+  sources?: string[][];
+  source_table?: string[];
+  source_indices?: number[][];
+  filters?: NativeDenyListFilterData;
+};
+type NativeTriggerStrategy = {
+  type: "to-next-comma";
+  stop_words?: string[];
+  max_length?: number;
+} | {
+  type: "to-end-of-line";
+} | {
+  type: "n-words";
+  count: number;
+} | {
+  type: "company-id-value";
+} | {
+  type: "address";
+  max_chars?: number;
+} | {
+  type: "match-pattern";
+  pattern: string;
+  flags?: string;
+};
+type NativeTriggerValidation = {
+  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;
+} | {
+  type: "valid-id";
+  validator: string;
+};
+type NativeTriggerRule = {
+  trigger: string;
+  label: string;
+  strategy: NativeTriggerStrategy;
+  validations: NativeTriggerValidation[];
+  include_trigger: boolean;
+};
+type NativeTriggerData = {
+  rules: NativeTriggerRule[];
+  address_stop_keywords: string[];
+  party_position_terms: string[];
+  post_nominals: string[];
+  sentence_terminal_currency_terms: string[];
+  phone_extension_labels: string[];
+  number_markers: string[];
+  number_labels: string[];
+};
+type NativeLegalFormData = {
+  suffixes: string[];
+  normalized_boundary_suffixes: string[];
+  normalized_in_name_words: string[];
+  normalized_suffix_words: string[];
+  role_heads: string[];
+  sentence_verb_indicators: string[];
+  clause_noun_heads: string[];
+  connector_prose_heads: string[];
+  structural_single_cap_prefixes: string[];
+  leading_clause_phrases: string[];
+  leading_clause_direct_prefixes: string[];
+  connector_words: string[];
+  and_connector_words: string[];
+  in_name_prepositions: string[];
+  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: 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 NativeCoreferencePatternData = {
+  pattern: string;
+  flags: string;
+};
+type NativeCoreferenceData = {
+  definition_patterns: NativeCoreferencePatternData[];
+  role_stop_terms: string[];
+  legal_form_aliases: string[];
+  organization_suffixes: string[];
+  organization_determiners: string[];
+};
+type NativeNameCorpusData = {
+  first_names: string[];
+  surnames: string[];
+  title_tokens: string[];
+  title_abbreviations: string[];
+  excluded_words: string[];
+  common_words: string[];
+  non_western_names: string[];
+  excluded_all_caps: string[];
+  ja_suffixes: string[];
+  arabic_connectors: string[];
+  relation_connectors: string[];
+  hyphenated_prefixes: string[];
+  cjk_non_person_terms: string[];
+  cjk_surname_starters: string[];
+  organization_terms: string[];
+};
+type NativeNameCorpusMode = "full" | "supplemental";
+type NativeZonePatternData = {
+  pattern: string;
+  flags: string;
+};
+type NativeZoneSigningClauseData = {
+  prefix: string;
+  suffix: string;
+  prepositions: string[];
+};
+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[];
+};
+type NativeHotwordRule = {
+  hotwords: string[];
+  target_labels: string[];
+  score_adjustment: number;
+  reclassify_to?: string;
+  proximity_before: number;
+  proximity_after: number;
+};
+type NativeHotwordRuleData = {
+  rules: NativeHotwordRule[];
+  pattern_rule_indices: number[];
+};
+type NativeSignatureData = {
+  labels: string[];
+  witness_phrases: string[];
+  name_particles: string[];
+  post_nominal_suffixes: string[];
+  organization_suffixes: string[];
+  image_stub_prefixes: string[];
+};
+type NativePreparedSearchConfig = {
+  regex_patterns: NativeSearchPattern[];
+  custom_regex_patterns: NativeSearchPattern[];
+  literal_patterns: NativeSearchPattern[];
+  regex_options: NativeSearchOptions;
+  custom_regex_options: NativeSearchOptions;
+  literal_options: NativeSearchOptions;
+  literal_patterns_from_deny_list_data?: boolean;
+  allowed_labels: string[];
+  threshold: number;
+  confidence_boost: boolean;
+  slices: {
+    regex: PatternSlice;
+    custom_regex: PatternSlice;
+    legal_forms?: PatternSlice;
+    triggers?: PatternSlice;
+    deny_list: PatternSlice;
+    street_types?: PatternSlice;
+    gazetteer: PatternSlice;
+    countries: PatternSlice;
+    hotwords?: PatternSlice;
+  };
+  regex_meta: NativeRegexMatchMeta[];
+  custom_regex_meta: NativeRegexMatchMeta[];
+  deny_list_data?: NativeDenyListMatchData;
+  false_positive_filters?: NativeDenyListFilterData;
+  gazetteer_data?: NativeGazetteerData;
+  country_data?: NativeCountryData;
+  hotword_data?: NativeHotwordRuleData;
+  trigger_data?: NativeTriggerData;
+  legal_form_data?: NativeLegalFormData;
+  address_seed_data?: NativeAddressSeedData;
+  zone_data?: NativeZoneData;
+  address_context_data?: NativeAddressContextData;
+  coreference_data?: NativeCoreferenceData;
+  name_corpus_data?: NativeNameCorpusData;
+  signature_data?: NativeSignatureData;
+  name_corpus_mode?: NativeNameCorpusMode;
+  date_data?: NativeDateData;
+  monetary_data?: NativeMonetaryData;
+};
+//#endregion
 //#region src/types.d.ts
 /**
  * Fields shared by every entity span in the source text.
@@ -53,146 +361,6 @@ 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";
-  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. */
@@ -222,507 +390,213 @@ type RedactionResult = {
   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;
+//#endregion
+//#region src/native.d.ts
+type NativeBindingOperatorConfig = {
+  operators?: Record<string, OperatorType>;
+  redactString?: string;
+};
+type NativeDiagnosticsBatchCallback = (diagnosticsJson: string) => void;
+type NativeResultEventCallback = (eventJson: string) => void;
+type NativeBindingRedactionEntry = {
+  placeholder: string;
+  original: string;
+};
+type NativeBindingOperatorEntry = {
+  placeholder: string;
+  operator: OperatorType;
+};
+type NativeBindingPipelineEntity = {
+  start: number;
+  end: number;
   label: string;
-  variants?: readonly string[];
+  text: string;
+  score: number;
+  source: string;
+  sourceDetail?: string | null;
 };
-/**
- * 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;
+type NativeBindingRedactionResult = {
+  redactedText: string;
+  redactionMap: NativeBindingRedactionEntry[];
+  operatorMap: NativeBindingOperatorEntry[];
+  entityCount: number;
 };
-/**
- * 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 NativeBindingStaticRedactionResult = {
+  resolvedEntities: NativeBindingPipelineEntity[];
+  redaction: NativeBindingRedactionResult;
+};
+type NativePreparedSearchBinding = {
+  prepareDiagnosticsJson?: () => string;
+  warmLazyRegex?: () => void;
+  warm_lazy_regex?: () => void;
+  warmLazyRegexDiagnosticsJson?: () => string;
+  warm_lazy_regex_diagnostics_json?: () => string;
+  redactStaticEntities: (fullText: string, operators?: NativeBindingOperatorConfig) => NativeBindingStaticRedactionResult;
+  redactStaticEntitiesJson?: (fullText: string, operators?: NativeBindingOperatorConfig) => string;
+  redactStaticEntitiesResultStreamJson?: (fullText: string, operators: NativeBindingOperatorConfig | undefined, onEvent: NativeResultEventCallback) => string;
+  redactStaticEntitiesDiagnosticsJson?: (fullText: string, operators?: NativeBindingOperatorConfig) => string;
+  redactStaticEntitiesDiagnosticsStreamJson?: (fullText: string, operators: NativeBindingOperatorConfig | undefined, onBatch: NativeDiagnosticsBatchCallback) => string;
+  redactStaticEntitiesSummaryDiagnosticsJson?: (fullText: string, operators?: NativeBindingOperatorConfig) => string;
+};
+type NativeAnonymizeBinding = {
+  normalizeForSearch: (text: string) => string;
+  nativePackageVersion: () => string;
+  NativePreparedSearch: {
+    fromConfigJsonBytes: (configJson: Uint8Array) => NativePreparedSearchBinding;
+    fromPreparedPackageBytes: (packageBytes: Uint8Array) => NativePreparedSearchBinding;
+    fromPreparedPackageBytesWithoutCache?: (packageBytes: Uint8Array) => NativePreparedSearchBinding;
+    fromTrustedPreparedPackageBytes?: (packageBytes: Uint8Array) => NativePreparedSearchBinding;
+    fromTrustedPreparedPackageBytesWithoutCache?: (packageBytes: Uint8Array) => NativePreparedSearchBinding;
+  };
+  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 PipelineConfig = {
-  threshold: number;
-  enableTriggerPhrases: boolean;
-  enableRegex: boolean;
-  /**
-   * 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;
+type NativeOperatorConfig = {
+  operators?: Record<string, OperatorType>;
+  redactString?: string;
 };
-//#endregion
-//#region src/detectors/regex.d.ts
-type RegexMeta = {
+type NativePipelineEntity = {
+  start: number;
+  end: number;
   label: string;
+  text: string;
   score: number;
-  sourceDetail?: Entity["sourceDetail"]; /** Post-match stdnum validator for confirmation. */
-  validator?: Validator; /** Extract the identifier portion when context is part of the regex span. */
-  validatorInput?: (text: string) => string;
+  source: string;
+  sourceDetail?: string;
 };
-/** 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" | "enableNameCorpus" | "nameCorpusLanguages" | "denyListCountries" | "denyListRegions" | "denyListExcludeCategories" | "customDenyList" | "dictionaries" | "enableCountries">;
-/**
- * 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.
- */
-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[];
+type NativeRedactionResult = {
+  redactedText: string;
+  redactionMap: Map<string, string>;
+  operatorMap: Map<string, OperatorType>;
+  entityCount: number;
 };
-/**
- * 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/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 NativeStaticRedactionResult = {
+  resolvedEntities: NativePipelineEntity[];
+  redaction: NativeRedactionResult;
 };
-type CountryVariant = "name" | "alias" | "alpha3" | "alpha2";
-//#endregion
-//#region src/build-unified-search.d.ts
-type PatternSlice = {
-  start: number;
-  end: number;
+type NativeSearchPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativePreparedSearchConfig;
+  compressed?: boolean;
 };
-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 NativeSearchPackageInput = NativePreparedSearchConfig | string | Uint8Array;
+type SharedNativeSearchPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativeSearchPackageInput;
+  compressed?: 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;
+type SharedNativePreparedPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  packageBytes: Uint8Array;
 };
-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;
+type SharedNativeRedactTextJsonOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativeSearchPackageInput;
+  fullText: string;
+  operators?: NativeOperatorConfig;
 };
-/**
- * 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[];
+type SharedNativeRedactTextOptions = SharedNativeRedactTextJsonOptions;
+type SharedNativeDiagnosticsJsonOptions = SharedNativeRedactTextJsonOptions;
+type SharedNativeDiagnosticsStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
+  onBatch: NativeDiagnosticsBatchCallback;
 };
-/**
- * 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;
-  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;
-  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;
-  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;
+type SharedNativeRedactTextStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
+  onEvent: NativeResultEventCallback;
 };
-/** 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;
+type NativeNormalizeOptions = {
+  binding: NativeAnonymizeBinding;
+  text: string;
 };
-/**
- * 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: ({
+type NativeAnonymizerFromConfigOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativePreparedSearchConfig;
+};
+type NativeAnonymizerFromPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  packageBytes: Uint8Array;
+};
+type NativePipelineFromPackageOptions = NativeAnonymizerFromPackageOptions;
+type NativeBindingVersionOptions = {
+  binding: NativeAnonymizeBinding;
+  expectedVersion: string;
+};
+declare class PreparedNativeAnonymizer {
+  #private;
+  constructor(prepared: NativePreparedSearchBinding);
+  prepareDiagnosticsJson(): string | null;
+  prepare_diagnostics_json(): string | null;
+  warmLazyRegex(): void;
+  warm_lazy_regex(): void;
+  warmLazyRegexDiagnosticsJson(): string | null;
+  warm_lazy_regex_diagnostics_json(): string | null;
+  redactStaticEntities(fullText: string, operators?: NativeOperatorConfig): NativeStaticRedactionResult;
+  redact_text(fullText: string, operators?: NativeOperatorConfig): NativeStaticRedactionResult;
+  redact_text_json(fullText: string, operators?: NativeOperatorConfig): string;
+  redactTextJson(fullText: string, operators?: NativeOperatorConfig): string;
+  redactTextStreamJson(fullText: string, onEvent: NativeResultEventCallback, operators?: NativeOperatorConfig): string | null;
+  redact_text_stream_json(fullText: string, onEvent: NativeResultEventCallback, operators?: NativeOperatorConfig): string | null;
+  redactStaticEntitiesDiagnosticsJson(fullText: string, operators?: NativeOperatorConfig): string | null;
+  diagnostics_json(fullText: string, operators?: NativeOperatorConfig): string | null;
+  diagnosticsStreamJson(fullText: string, onBatch: NativeDiagnosticsBatchCallback, operators?: NativeOperatorConfig): string | null;
+  diagnostics_stream_json(fullText: string, onBatch: NativeDiagnosticsBatchCallback, operators?: NativeOperatorConfig): string | null;
+  redactStaticEntitiesSummaryDiagnosticsJson(fullText: string, operators?: NativeOperatorConfig): string | null;
+  summary_diagnostics_json(fullText: string, operators?: NativeOperatorConfig): string | null;
+}
+declare class PreparedNativePipeline {
+  #private;
+  constructor(anonymizer: PreparedNativeAnonymizer);
+  prepareDiagnosticsJson(): string | null;
+  prepare_diagnostics_json(): string | null;
+  warmLazyRegex(): void;
+  warm_lazy_regex(): void;
+  warmLazyRegexDiagnosticsJson(): string | null;
+  warm_lazy_regex_diagnostics_json(): string | null;
+  redactText(fullText: string, operators?: NativeOperatorConfig): NativeStaticRedactionResult;
+  redact_text(fullText: string, operators?: NativeOperatorConfig): NativeStaticRedactionResult;
+  redact_text_json(fullText: string, operators?: NativeOperatorConfig): string;
+  redactTextJson(fullText: string, operators?: NativeOperatorConfig): string;
+  redactTextStreamJson(fullText: string, onEvent: NativeResultEventCallback, operators?: NativeOperatorConfig): string | null;
+  redact_text_stream_json(fullText: string, onEvent: NativeResultEventCallback, operators?: NativeOperatorConfig): string | null;
+  redactTextDiagnosticsJson(fullText: string, operators?: NativeOperatorConfig): string | null;
+  diagnostics_json(fullText: string, operators?: NativeOperatorConfig): string | null;
+  diagnosticsStreamJson(fullText: string, onBatch: NativeDiagnosticsBatchCallback, operators?: NativeOperatorConfig): string | null;
+  diagnostics_stream_json(fullText: string, onBatch: NativeDiagnosticsBatchCallback, operators?: NativeOperatorConfig): string | null;
+  redactTextSummaryDiagnosticsJson(fullText: string, operators?: NativeOperatorConfig): string | null;
+  summary_diagnostics_json(fullText: string, operators?: NativeOperatorConfig): string | null;
+}
+declare const encodeNativeSearchConfig: (config: NativePreparedSearchConfig) => Uint8Array;
+declare const encodeNativeSearchConfigInput: (config: NativeSearchPackageInput) => Uint8Array;
+declare const getNativeBindingVersion: (binding: NativeAnonymizeBinding) => string;
+declare const assertNativeBindingVersion: ({
+  binding,
+  expectedVersion
+}: NativeBindingVersionOptions) => void;
+declare const prepareNativeSearchPackage: ({
+  binding,
   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;
-};
-/**
- * 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[]>;
+  compressed
+}: NativeSearchPackageOptions) => Uint8Array;
+declare const createNativeAnonymizerFromConfig: ({
+  binding,
+  config
+}: NativeAnonymizerFromConfigOptions) => PreparedNativeAnonymizer;
+declare const createNativeAnonymizerFromPackage: ({
+  binding,
+  packageBytes
+}: NativeAnonymizerFromPackageOptions) => PreparedNativeAnonymizer;
+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/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 Unused. Kept for signature compatibility;
- *   coref alias links now travel on the entities
- *   themselves (`corefSourceText`).
- */
-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.
@@ -735,483 +609,60 @@ declare const exportRedactionKey: (redactionMap: Map<string, string>, operatorMa
  */
 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: () => 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/address-seeds.d.ts
-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).
- *
- * 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/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[];
-//#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;
-};
-/**
- * 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;
+//#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;
+};
+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, CURRENCY_PATTERN_META, type ChunkSpan, type CountryCode, type CustomDenyListEntry, type CustomRegexPattern, DATE_PATTERN_META, DEFAULT_ENTITY_LABELS, 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 NerInferenceFn, OPERATOR_REGISTRY, OPERATOR_TYPES, type OperatorConfig, type OperatorType, type PipelineConfig, type PipelineContext, type PipelineOptions, type PipelineSearchOptions, 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, chunkTextWithOffsets, classifyZones, computeChunkOffsets, corefKey, createPipelineContext, deanonymise, decodeSpans, decodeTokenSpans, detectNameCorpus, ensureDenyListData, exportRedactionKey, extractDefinedTerms, filterFalsePositives, findCoreferenceSpans, getCurrencyPatterns, getDatePatterns, getNameCorpusNonWesternNames, initAddressComponents, initHotwordRules, initNameCorpus, initZoneClassifier, levenshtein, mergeAndDedup, mergeChunkEntities, normalizeForSearch, prepareBatch, preparePipelineSearch, processAddressSeeds, processDenyListMatches, processGazetteerMatches, processLegalFormMatches, processRegexMatches, processTriggerMatches, propagateOrgNames, redactText, resolveCountries, resolveOperator, runPipeline, runUnifiedSearch, sanitizeEntities, tokenizeText, warmLegalRoleHeads };
+export { type AnonymisationOperator, DEFAULT_ENTITY_LABELS, DETECTION_SOURCES, DETECTOR_PRIORITY, type DetectionSource, type Entity, LoadPreparedPackageOptions, NativeAnonymizeBinding, NativeAnonymizerFromConfigOptions, NativeAnonymizerFromPackageOptions, NativeBindingVersionOptions, NativeDiagnosticsBatchCallback, NativeNormalizeOptions, NativeOperatorConfig, NativePipelineEntity, NativePipelineFromPackageOptions, NativePreparedSearchBinding, type NativePreparedSearchConfig, NativeRedactionResult, NativeResultEventCallback, NativeSearchPackageInput, NativeSearchPackageOptions, NativeStaticRedactionResult, OPERATOR_TYPES, type OperatorConfig, type OperatorType, PrepareSearchPackageOptions, PreparedAnonymizer, PreparedNativeAnonymizer, PreparedNativePipeline, PreparedPackageSource, PreparedSearch, type RedactionResult, type ReviewDecision, type ReviewedEntity, SharedNativeDiagnosticsJsonOptions, SharedNativeDiagnosticsStreamJsonOptions, SharedNativePreparedPackageOptions, SharedNativeRedactTextJsonOptions, SharedNativeRedactTextOptions, SharedNativeRedactTextStreamJsonOptions, SharedNativeSearchPackageOptions, WasmBindingOptions, assertNativeBindingVersion, createNativeAnonymizerFromConfig, createNativeAnonymizerFromPackage, createNativePipelineFromPackage, deanonymise, defaultPackageUrl, diagnostics_json, diagnostics_stream_json, encodeNativeSearchConfig, encodeNativeSearchConfigInput, exportRedactionKey, getBinding, getDefaultPipeline, getNativeBindingVersion, loadDefaultPipeline, loadPipeline, load_prepared_package, native_package_version, normalize_for_search, prepareNativeSearchPackage, prepare_search_package, redactDefaultText, redactDefaultTextJson, redact_text, redact_text_json, redact_text_stream_json, summary_diagnostics_json };
 //# sourceMappingURL=wasm.d.mts.map