@stll/anonymize 1.5.0 → 2.0.0-alpha.1

package/dist/native.d.mts

@@ -0,0 +1,1158 @@
+import { i as DetectionSource, n as DETECTION_SOURCES, o as OperatorType } from "./constants2.mjs";
+import { Validator } from "@stll/stdnum";
+import { TextSearch } from "@stll/text-search";
+
+//#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";
+};
+type DateMonthData = Record<string, string[]>;
+type YearWordData = Record<string, string[]>;
+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[];
+    }>;
+  };
+};
+//#endregion
+//#region src/context.d.ts
+/**
+ * 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;
+};
+//#endregion
+//#region src/detectors/deny-list.d.ts
+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.
+ */
+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;
+};
+//#endregion
+//#region src/detectors/address-seeds.d.ts
+type AddressSeedData = {
+  boundary_words: string[];
+  br_cep_cue_words: string[];
+  unit_abbreviations: string[];
+};
+//#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
+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;
+};
+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 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 NativeSigningPlaceGuardData = {
+  prefix_phrases: string[];
+  suffix_phrases: string[];
+};
+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 NativeDateData = {
+  month_names_by_language: DateMonthData;
+  year_words_by_language: YearWordData;
+};
+type NativeMonetaryData = MonetaryData;
+type NativeAddressSeedData = AddressSeedData;
+type NativeAddressContextData = AddressContextData;
+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 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?: CountryData;
+  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;
+};
+type GazetteerData = {
+  /** Maps local pattern index to entry label. */labels: string[];
+  /**
+   * Whether each pattern is fuzzy (distance > 0).
+   * Used by the post-processor to assign scores.
+   */
+  isFuzzy: boolean[];
+};
+type UnifiedSearchInstance = {
+  /** Regex + triggers + legal-forms. */tsRegex: TextSearch; /** 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;
+};
+//#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;
+  text: string;
+  score: number;
+  source: string;
+  sourceDetail?: string | null;
+};
+type NativeBindingRedactionResult = {
+  redactedText: string;
+  redactionMap: NativeBindingRedactionEntry[];
+  operatorMap: NativeBindingOperatorEntry[];
+  entityCount: number;
+};
+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;
+};
+type NativeOperatorConfig = {
+  operators?: Record<string, OperatorType>;
+  redactString?: string;
+};
+type NativePipelineEntity = {
+  start: number;
+  end: number;
+  label: string;
+  text: string;
+  score: number;
+  source: string;
+  sourceDetail?: string;
+};
+type NativeRedactionResult = {
+  redactedText: string;
+  redactionMap: Map<string, string>;
+  operatorMap: Map<string, OperatorType>;
+  entityCount: number;
+};
+type NativeStaticRedactionResult = {
+  resolvedEntities: NativePipelineEntity[];
+  redaction: NativeRedactionResult;
+};
+type NativeSearchPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativePreparedSearchConfig;
+  compressed?: boolean;
+};
+type NativeSearchPackageInput = NativePreparedSearchConfig | string | Uint8Array;
+type SharedNativeSearchPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativeSearchPackageInput;
+  compressed?: boolean;
+};
+type SharedNativePreparedPackageOptions = {
+  binding: NativeAnonymizeBinding;
+  packageBytes: Uint8Array;
+};
+type SharedNativeRedactTextJsonOptions = {
+  binding: NativeAnonymizeBinding;
+  config: NativeSearchPackageInput;
+  fullText: string;
+  operators?: NativeOperatorConfig;
+};
+type SharedNativeRedactTextOptions = SharedNativeRedactTextJsonOptions;
+type SharedNativeDiagnosticsJsonOptions = SharedNativeRedactTextJsonOptions;
+type SharedNativeDiagnosticsStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
+  onBatch: NativeDiagnosticsBatchCallback;
+};
+type SharedNativeRedactTextStreamJsonOptions = SharedNativeRedactTextJsonOptions & {
+  onEvent: NativeResultEventCallback;
+};
+type NativeNormalizeOptions = {
+  binding: NativeAnonymizeBinding;
+  text: string;
+};
+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 native_package_version: (binding: NativeAnonymizeBinding) => string;
+declare const normalize_for_search: ({
+  binding,
+  text
+}: NativeNormalizeOptions) => string;
+declare const assertNativeBindingVersion: ({
+  binding,
+  expectedVersion
+}: NativeBindingVersionOptions) => void;
+declare const prepareNativeSearchPackage: ({
+  binding,
+  config,
+  compressed
+}: NativeSearchPackageOptions) => Uint8Array;
+declare const prepare_search_package: ({
+  binding,
+  config,
+  compressed
+}: SharedNativeSearchPackageOptions) => Uint8Array;
+declare const createNativeAnonymizerFromConfig: ({
+  binding,
+  config
+}: NativeAnonymizerFromConfigOptions) => PreparedNativeAnonymizer;
+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 diagnostics_stream_json: ({
+  binding,
+  config,
+  fullText,
+  operators,
+  onBatch
+}: SharedNativeDiagnosticsStreamJsonOptions) => string | null;
+declare const summary_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
+export { Entity as $, createNativePipelineFromPackage as A, prepare_search_package as B, SharedNativeRedactTextJsonOptions as C, assertNativeBindingVersion as D, SharedNativeSearchPackageOptions as E, getNativeBindingVersion as F, NativePreparedSearchConfig as G, redact_text_json as H, load_prepared_package as I, CustomDenyListEntry as J, PipelineContext as K, native_package_version as L, diagnostics_stream_json as M, encodeNativeSearchConfig as N, createNativeAnonymizerFromConfig as O, encodeNativeSearchConfigInput as P, DictionaryMeta as Q, normalize_for_search as R, SharedNativePreparedPackageOptions as S, SharedNativeRedactTextStreamJsonOptions as T, redact_text_stream_json as U, redact_text as V, summary_diagnostics_json as W, DenyListCategory as X, CustomRegexPattern as Y, Dictionaries as Z, PreparedNativeAnonymizer as _, NativeDiagnosticsBatchCallback as a, ReviewedEntity as at, SharedNativeDiagnosticsJsonOptions as b, NativePipelineEntity as c, TriggerRule as ct, NativeRedactionResult as d, GazetteerEntry as et, NativeResultEventCallback as f, PreparedAnonymizer as g, NativeStaticRedactionResult as h, NativeBindingVersionOptions as i, ReviewDecision as it, diagnostics_json as j, createNativeAnonymizerFromPackage as k, NativePipelineFromPackageOptions as l, TriggerStrategy as lt, NativeSearchPackageOptions as m, NativeAnonymizerFromConfigOptions as n, PipelineConfig as nt, NativeNormalizeOptions as o, TriggerExtension as ot, NativeSearchPackageInput as p, AnonymisationOperator as q, NativeAnonymizerFromPackageOptions as r, RedactionResult as rt, NativeOperatorConfig as s, TriggerGroupConfig as st, NativeAnonymizeBinding as t, OperatorConfig as tt, NativePreparedSearchBinding as u, TriggerValidation as ut, PreparedNativePipeline as v, SharedNativeRedactTextOptions as w, SharedNativeDiagnosticsStreamJsonOptions as x, PreparedSearch as y, prepareNativeSearchPackage as z };
+//# sourceMappingURL=native.d.mts.map