@stll/anonymize 1.5.0 → 2.0.0

package/dist/native.d.mts

@@ -0,0 +1,970 @@
+import { i as DetectionSource, n as DETECTION_SOURCES, o as OperatorType } from "./constants2.mjs";
+
+//#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.
+ */
+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/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;
+  assembleStaticSearchConfigJson?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
+  assembleStaticSearchPackageBytes?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
+  assembleStaticSearchCompressedPackageBytes?: (pipelineConfigJson: Uint8Array, dictionariesJson?: Uint8Array, gazetteerJson?: Uint8Array) => Uint8Array;
+};
+type NativeOperatorConfig = {
+  operators?: Record<string, OperatorType>;
+  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 { OperatorConfig as $, createNativePipelineFromPackage as A, prepare_search_package as B, SharedNativeRedactTextJsonOptions as C, assertNativeBindingVersion as D, SharedNativeSearchPackageOptions as E, getNativeBindingVersion as F, AnonymisationOperator as G, redact_text_json as H, load_prepared_package as I, DenyListCategory as J, CustomDenyListEntry as K, native_package_version as L, diagnostics_stream_json as M, encodeNativeSearchConfig as N, createNativeAnonymizerFromConfig as O, encodeNativeSearchConfigInput as P, GazetteerEntry 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, DictionaryMeta as X, Dictionaries as Y, Entity as Z, PreparedNativeAnonymizer as _, NativeDiagnosticsBatchCallback as a, TriggerGroupConfig as at, SharedNativeDiagnosticsJsonOptions as b, NativePipelineEntity as c, TriggerValidation as ct, NativeRedactionResult as d, PipelineConfig as et, NativeResultEventCallback as f, PreparedAnonymizer as g, NativeStaticRedactionResult as h, NativeBindingVersionOptions as i, TriggerExtension as it, diagnostics_json as j, createNativeAnonymizerFromPackage as k, NativePipelineFromPackageOptions as l, NativePreparedSearchConfig as lt, NativeSearchPackageOptions as m, NativeAnonymizerFromConfigOptions as n, ReviewDecision as nt, NativeNormalizeOptions as o, TriggerRule as ot, NativeSearchPackageInput as p, CustomRegexPattern as q, NativeAnonymizerFromPackageOptions as r, ReviewedEntity as rt, NativeOperatorConfig as s, TriggerStrategy as st, NativeAnonymizeBinding as t, RedactionResult as tt, NativePreparedSearchBinding as u, PreparedNativePipeline as v, SharedNativeRedactTextOptions as w, SharedNativeDiagnosticsStreamJsonOptions as x, PreparedSearch as y, prepareNativeSearchPackage as z };
+//# sourceMappingURL=native.d.mts.map