🥮 mooncakes.io

    moonbit-deid

    A MoonBit toolkit for detecting, replacing, and auditing PHI in Chinese and English clinical text.

    de-identification
    phi
    medical
    privacy
    nlp
    Download zip
    Author
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    26 days ago
    Downloads
    20

    Dependencies

    #moonbit-deid

    moonbit-deid is a deterministic, library-first toolkit for detecting and redacting personally identifiable information (PII/PHI) in Chinese and English clinical text. A redaction returns the transformed text together with findings, replacement offsets, and an audit report, so downstream systems can review what changed instead of treating masking as a black box.

    #Core capabilities

    • Chinese and English rules for names, identifiers, phones, email addresses, dates, medical records, insurance records, addresses, organizations, and context-labelled fields.
    • Regex-backed detection with confidence thresholds, disabled-rule handling, contextual rules, and deterministic overlap resolution.
    • Token, preserve-length, partial-mask, and stable-hash replacement modes.
    • Reusable policies with allowlisted ranges, denied rules, locale hints, and review-only operation.
    • Offset mappings between original and redacted text, audit exports, risk summaries, quality metrics, and integrity contracts.
    • Batch and streaming pipelines, structured field helpers, Unicode-safe boundaries, and an adapter for external NER entities.
    • Synthetic evaluation fixtures and a deterministic CLI benchmark.

    #Quick start

    ///|
    test {
      let result = redact("电话13800138000")
      inspect(result.text, content="电话[PHONE]")
      inspect(result.offsets.length() > 0, content="true")
    }

    Run the CLI with the latest local MoonBit toolchain:

    moon run --target wasm-gc cmd/main -- "姓名：张三 电话13800138000" --audit
moon run --target wasm-gc cmd/main -- --mode=preserve "Phone 415-555-1234"
moon run --target wasm-gc cmd/main -- --mode=partial "Email: zhang@example.com"
moon run --target wasm-gc cmd/main -- --mode=hash "电话13800138000"

    #CLI

    moon run cmd/main -- [options] [text]

    Supported options are --audit, --mode=preserve, --mode=partial, --mode=hash, --benchmark[=N], and --help. The benchmark uses fixed clinical fixtures and the same library pipeline as normal redaction.

    #Architecture

    1. rules.mbt, clinical_rules.mbt, and scanner.mbt define detectors and produce normalized findings.
    2. redaction_policy.mbt and pipeline_orchestration.mbt apply policy, confidence, locale, allowlist, and overlap decisions.
    3. deid.mbt, offset_mapping.mbt, and audit_exports.mbt apply replacements and preserve reviewable provenance.
    4. batch_pipeline.mbt, streaming_pipeline.mbt, structured_fields.mbt, ner_adapters.mbt, and evaluation.mbt provide integration surfaces for applications and test fixtures.

    The public convenience API is in public_api.mbt; lower-level functions stay available for applications that need explicit rules or policies.

    #Benchmarks

    Reproduce the local measurement with:

    moon run cmd/main -- --benchmark=100

    On 2026-08-19, three local runs processed 3 cases, 500 documents, 63,500 input characters, and 3,600 findings each. Elapsed times were 652 ms, 623 ms, and 649 ms. Full command output and methodology are recorded in BENCHMARKS.md; elapsed time is host-dependent.

    The repository currently contains 9,355 lines of production .mbt source, counted locally while excluding test files and generated build output. CI keeps a transparent lower-bound check of 8,000 production lines.

    #Tests and development

    The test suite covers ordinary cases and boundary behavior for malformed identifiers, checksums, empty input, Unicode code-unit boundaries, overlapping spans, protected ranges, structured fields, streaming chunks, external entities, mappings, batches, and evaluation denominators.

    moon fmt --check
moon info
moon check --target all --deny-warn
moon test --target all --deny-warn
moon run --target wasm-gc cmd/main -- --benchmark=10

    Generated interfaces are kept in pkg.generated.mbti and cmd/main/pkg.generated.mbti. Do not edit them manually; regenerate them with moon info.

    #CI

    .github/workflows/test.yml checks the current stable MoonBit toolchain on Ubuntu, macOS, and Windows. It verifies formatting, generated interfaces, strict type checking, tests, source scale, and the CLI benchmark smoke path. Publishing is deliberately a separate manual workflow so a normal pull request cannot publish a package accidentally.

    #Scope and license

    The package provides deterministic engineering primitives, not a claim of regulatory compliance. Production deployments should review rule coverage, thresholds, audit retention, and institution-specific policy.

    This project is licensed under the Apache License 2.0.

    DeidError

    source
    pub(all) suberror DeidError {
      DeidError(String)
    }

    impl Show for DeidError

    AnalyticsComparison

    source
    pub(all) struct AnalyticsComparison {
      left_id : String
      right_id : String
      finding_delta : Int
      risk_delta : Int
      length_delta : Int
      ratio_delta : Float
    } derive(
    Debug    )

    AuditReport

    source
    pub(all) struct AuditReport {
      input_length : Int
      output_length : Int
      finding_count : Int
      applied_count : Int
      counts : Map[String, Int]
      findings : Array[Finding]
      offsets : Array[OffsetMap]
    } derive(
    Debug    )

    AuditTotals

    source
    pub(all) struct AuditTotals {
      documents : Int
      findings : Int
      applied : Int
      protected_count : Int
      by_kind : Map[String, Int]
      by_risk : Map[String, Int]
    } derive(
    Debug    )

    BatchConfig

    source
    pub(all) struct BatchConfig {
      config : RedactionConfig
      stop_on_error : Bool
      retain_empty : Bool
      max_documents : Int
    } derive(Eq, 
    Debug    )

    BatchConfig::default

    source
    fn BatchConfig::default() -> BatchConfig

    BatchDiagnostic

    source
    pub(all) struct BatchDiagnostic {
      id : String
      ok : Bool
      message : String
      finding_count : Int
    } derive(Eq, 
    Debug    )

    BatchItem

    source
    pub(all) struct BatchItem {
      id : String
      text : String
    } derive(Eq, 
    Debug    )

    BatchOutcome

    source
    pub(all) struct BatchOutcome {
      results : Array[BatchResult]
      diagnostics : Array[BatchDiagnostic]
      totals : AuditTotals
    } derive(
    Debug    )

    BatchResult

    source
    pub(all) struct BatchResult {
      id : String
      result : DeidResult
    } derive(
    Debug    )

    BatchSummary

    source
    pub(all) struct BatchSummary {
      document_count : Int
      finding_count : Int
      counts : Map[String, Int]
    } derive(
    Debug    )

    BenchmarkCase

    source
    pub(all) struct BenchmarkCase {
      name : String
      description : String
      documents : Array[String]
      expected_findings : Int
    } derive(Eq, 
    Debug    )

    BenchmarkResult

    source
    pub(all) struct BenchmarkResult {
      name : String
      documents : Int
      repetitions : Int
      input_characters : Int
      findings : Int
      output_characters : Int
    } derive(Eq, 
    Debug    )

    ChunkPolicy

    source
    pub(all) struct ChunkPolicy {
      context_window : Int
      separator : String
      config : RedactionConfig
    } derive(Eq, 
    Debug    )

    ChunkPolicy::default

    source
    fn ChunkPolicy::default() -> ChunkPolicy

    ChunkResult

    source
    pub(all) struct ChunkResult {
      chunk_id : String
      original_length : Int
      redacted_length : Int
      result : DeidResult
    } derive(
    Debug    )

    ConfidenceBand

    source
    pub enum ConfidenceBand {
      Low
      Medium
      High
      Certain
    } derive(Compare, Eq, 
    Debug    )

    DeidOptions

    source
    pub(all) struct DeidOptions {
      mode : ReplacementMode
      min_confidence : Int
      include_disabled_rules : Bool
    } derive(Eq, 
    Debug    )

    DeidOptions::default

    source
    fn DeidOptions::default() -> DeidOptions

    DeidResult

    source
    pub(all) struct DeidResult {
      text : String
      findings : Array[Finding]
      offsets : Array[OffsetMap]
      audit : AuditReport
    } derive(
    Debug    )

    Diagnostic

    source
    pub(all) struct Diagnostic {
      code : String
      severity : DiagnosticSeverity
      message : String
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    DiagnosticSeverity

    source
    pub(all) enum DiagnosticSeverity {
      Info
      Warning
      Error
    } derive(Eq, 
    Debug    )

    DocumentAnalytics

    source
    pub(all) struct DocumentAnalytics {
      id : String
      input_length : Int
      output_length : Int
      finding_count : Int
      risk_score : Int
      redaction_ratio : Float
      average_confidence : Float
      kinds : Map[String, Int]
    } derive(
    Debug    )

    DocumentSection

    source
    pub(all) struct DocumentSection {
      title : String
      kind : SectionKind
      start : Int
      end : Int
      text : String
    } derive(Eq, 
    Debug    )

    EntityBatch

    source
    pub(all) struct EntityBatch {
      source : String
      entities : Array[EntityInput]
      invalid_count : Int
    } derive(Eq, 
    Debug    )

    EntityInput

    source
    pub(all) struct EntityInput {
      label : String
      kind : PhiKind
      start : Int
      end : Int
      confidence : Int
      source : String
    } derive(Eq, 
    Debug    )

    EvaluationCase

    source
    pub(all) struct EvaluationCase {
      id : String
      text : String
      expected : Array[Span]
    } derive(Eq, 
    Debug    )

    EvaluationResult

    source
    pub(all) struct EvaluationResult {
      cases : Int
      expected : Int
      predicted : Int
      true_positive : Int
      false_positive : Int
      false_negative : Int
    } derive(Eq, 
    Debug    )

    EvaluationResult::f1

    source
    fn EvaluationResult::f1(self : EvaluationResult) -> Float

    EvaluationResult::precision

    source
    fn EvaluationResult::precision(self : EvaluationResult) -> Float

    EvaluationResult::recall

    source
    fn EvaluationResult::recall(self : EvaluationResult) -> Float

    ExternalEntity

    source
    pub(all) struct ExternalEntity {
      kind : PhiKind
      label : String
      start : Int
      end : Int
      confidence : Int
      source : String
    } derive(Eq, 
    Debug    )

    FieldValue

    source
    pub(all) struct FieldValue {
      key : String
      value : String
      start : Int
      end : Int
      separator : String
    } derive(Eq, 
    Debug    )

    Finding

    source
    pub(all) struct Finding {
      id : String
      kind : PhiKind
      label : String
      start : Int
      end : Int
      text : String
      replacement : String
      rule_id : String
      confidence : Int
    } derive(Eq, 
    Debug    )

    IdentifierKind

    source
    pub enum IdentifierKind {
      PhoneIdentifier
      EmailIdentifier
      GovernmentIdentifier
      AccountIdentifier
      DeviceIdentifier
      LocationIdentifier
      UnknownIdentifier
    } derive(Eq, 
    Debug    )

    LineColumn

    source
    pub(all) struct LineColumn {
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    LocaleHint

    source
    pub(all) enum LocaleHint {
      Chinese
      English
      Mixed
      Neutral
    } derive(Eq, 
    Debug    )

    Locale hints used when selecting a rule pack. A hint never changes the input text; it only narrows the deterministic detector set.
    impl Show for LocaleHint

    MappingIndex

    source
    pub(all) struct MappingIndex {
      original_length : Int
      redacted_length : Int
      segments : Array[MappingSegment]
    } derive(
    Debug    )

    MappingIndex::changed_original_spans

    source
    fn MappingIndex::changed_original_spans(self : MappingIndex) -> Array[Span]

    MappingIndex::changed_redacted_spans

    source
    fn MappingIndex::changed_redacted_spans(self : MappingIndex) -> Array[Span]

    MappingIndex::describe

    source
    fn MappingIndex::describe(self : MappingIndex) -> String

    MappingIndex::is_monotonic

    source
    fn MappingIndex::is_monotonic(self : MappingIndex) -> Bool

    MappingIndex::original_line_column

    source
    fn MappingIndex::original_line_column(self : MappingIndex, original : String, position : Int) -> LineColumn

    MappingIndex::original_range_to_redacted

    source
    fn MappingIndex::original_range_to_redacted(self : MappingIndex, span : Span) -> Span

    MappingIndex::original_to_redacted

    source
    fn MappingIndex::original_to_redacted(self : MappingIndex, position : Int) -> Int

    MappingIndex::redacted_line_column

    source
    fn MappingIndex::redacted_line_column(self : MappingIndex, redacted : String, position : Int) -> LineColumn

    MappingIndex::redacted_range_to_original

    source
    fn MappingIndex::redacted_range_to_original(self : MappingIndex, span : Span) -> Span

    MappingIndex::redacted_to_original

    source
    fn MappingIndex::redacted_to_original(self : MappingIndex, position : Int) -> Int

    MappingIndex::segment_for_original

    source
    fn MappingIndex::segment_for_original(self : MappingIndex, position : Int) -> MappingSegment?

    MappingIndex::segment_for_redacted

    source
    fn MappingIndex::segment_for_redacted(self : MappingIndex, position : Int) -> MappingSegment?

    MappingSegment

    source
    pub(all) struct MappingSegment {
      original : Span
      redacted : Span
      finding_id : String
      kind : PhiKind
    } derive(Eq, 
    Debug    )

    MatchQuality

    source
    pub(all) struct MatchQuality {
      finding_id : String
      lexical : Int
      contextual : Int
      structural : Int
      checksum : Int
      total : Int
      band : ConfidenceBand
    } derive(Eq, 
    Debug    )

    OffsetMap

    source
    pub(all) struct OffsetMap {
      original_start : Int
      original_end : Int
      replacement_start : Int
      replacement_end : Int
      finding_id : String
    } derive(Eq, 
    Debug    )

    PhiKind

    source
    pub(all) enum PhiKind {
      PersonName
      IdNumber
      Phone
      Date
      Email
      Address
      MedicalRecord
      Insurance
      Organization
      Custom(String)
    } derive(Eq, 
    Debug    )

    PHI categories recognized by the built-in rules and extension points.
    impl Show for PhiKind

    PipelineConfig

    source
    pub(all) struct PipelineConfig {
      policy : RedactionPolicy
      rules : Array[Rule]
      normalize_input : Bool
      include_keyword_diagnostics : Bool
      keep_review_findings : Bool
    } derive(Eq, 
    Debug    )

    PipelineConfig::default

    source

    PipelineResult

    source
    pub(all) struct PipelineResult {
      original : String
      normalized : String
      findings : Array[Finding]
      result : DeidResult
      statistics : ScanStatistics
      diagnostics : Array[Diagnostic]
      trace : Array[PipelineTrace]
    } derive(
    Debug    )

    PipelineResult::audit

    source

    PipelineResult::text

    source
    fn PipelineResult::text(self : PipelineResult) -> String

    PipelineStage

    source
    pub enum PipelineStage {
      Normalize
      Detect
      Resolve
      Apply
      Audit
      Complete
    } derive(Eq, 
    Debug    )

    PipelineTrace

    source
    pub(all) struct PipelineTrace {
      stage : PipelineStage
      message : String
    } derive(Eq, 
    Debug    )

    PlaceholderRegistry

    source
    pub(all) struct PlaceholderRegistry {
      values : Map[String, String]
    } derive(Eq, 
    Debug    )

    PlaceholderRegistry::contains

    source
    fn PlaceholderRegistry::contains(self : PlaceholderRegistry, kind : PhiKind) -> Bool

    PlaceholderRegistry::default

    source

    PlaceholderRegistry::get

    source
    fn PlaceholderRegistry::get(self : PlaceholderRegistry, kind : PhiKind) -> String

    PlaceholderRegistry::set

    source
    fn PlaceholderRegistry::set(self : PlaceholderRegistry, kind : PhiKind, value : String) -> Unit

    PolicyAction

    source
    pub enum PolicyAction {
      Redact
      ReviewOnly
      Keep
    } derive(Eq, 
    Debug    )

    PolicyDecision

    source
    pub(all) struct PolicyDecision {
      finding_id : String
      action : PolicyAction
      reason : String
    } derive(Eq, 
    Debug    )

    PrivacyClass

    source
    pub enum PrivacyClass {
      DirectIdentifier
      QuasiIdentifier
      ContactIdentifier
      AccountIdentifier
      ContextualIdentifier
      NonIdentifier
    } derive(Compare, Eq, 
    Debug    )

    PrivacySummary

    source
    pub(all) struct PrivacySummary {
      direct : Int
      quasi : Int
      contact : Int
      account : Int
      contextual : Int
      non_identifier : Int
    } derive(Eq, 
    Debug    )

    ProcessingManifest

    source
    pub(all) struct ProcessingManifest {
      document_id : String
      input_checksum : String
      output_checksum : String
      rule_pack_checksum : String
      policy_name : String
      finding_count : Int
      applied_count : Int
      generated_at : String
    } derive(Eq, 
    Debug    )

    Profile

    source
    pub(all) enum Profile {
      ChineseClinical
      EnglishClinical
      HighPrecision
      AllBuiltins
    } derive(Eq, 
    Debug    )

    ProtectedRange

    source
    pub(all) struct ProtectedRange {
      start : Int
      end : Int
      reason : String
    } derive(Eq, 
    Debug    )

    A range that is explicitly protected from automatic replacement.

    ProtectedRange::as_span

    source
    fn ProtectedRange::as_span(self : ProtectedRange) -> Span

    PseudonymRegistry

    source
    pub(all) struct PseudonymRegistry {
      salt : String
      values : Map[String, String]
    } derive(Eq, 
    Debug    )

    PseudonymRegistry::checksum

    source
    fn PseudonymRegistry::checksum(self : PseudonymRegistry) -> String

    PseudonymRegistry::new

    source
    fn PseudonymRegistry::new(salt : String) -> PseudonymRegistry

    PseudonymRegistry::size

    source
    fn PseudonymRegistry::size(self : PseudonymRegistry) -> Int

    PseudonymRegistry::token

    source
    fn PseudonymRegistry::token(self : PseudonymRegistry, value : String, kind : PhiKind) -> String

    RedactionConfig

    source
    pub(all) struct RedactionConfig {
      policy : RedactionPolicy
      salt : String
      token_prefix : String
      keep_first : Int
      keep_last : Int
      keep_whitespace : Bool
    } derive(Eq, 
    Debug    )

    RedactionConfig::default

    source

    RedactionContract

    source
    pub(all) struct RedactionContract {
      valid_findings : Bool
      monotonic_offsets : Bool
      newline_preserved : Bool
      output_changed : Bool
      audit_consistent : Bool
      passes : Bool
    } derive(Eq, 
    Debug    )

    RedactionPolicy

    source
    pub(all) struct RedactionPolicy {
      name : String
      locale : LocaleHint
      action : PolicyAction
      mode : ReplacementMode
      min_confidence : Int
      protected_ranges : Array[ProtectedRange]
      allowed_kinds : Array[PhiKind]
      denied_rule_ids : Array[String]
      context_window : Int
    } derive(Eq, 
    Debug    )

    A reusable selection and masking policy for one application.

    RedactionPolicy::default

    source

    RedactionPolicy::review

    source

    RedactionPolicy::strict

    source

    ReplacementMode

    source
    pub(all) enum ReplacementMode {
      Token
      PreserveLength
      Partial
      StableHash
    } derive(Eq, 
    Debug    )

    Replacement policy used when applying findings to text.

    RetentionPolicy

    source
    pub(all) struct RetentionPolicy {
      keep_original : Bool
      keep_audit : Bool
      keep_offsets : Bool
      redact_logs : Bool
    } derive(Eq, 
    Debug    )

    RetentionPolicy::minimal

    source

    RetentionPolicy::safe_default

    source
    fn RetentionPolicy::safe_default() -> RetentionPolicy

    RiskLevel

    source
    pub(all) enum RiskLevel {
      Low
      Medium
      High
      Critical
    } derive(Compare, Eq, 
    Debug    )

    impl Show for RiskLevel

    Rule

    source
    pub(all) struct Rule {
      id : String
      label : String
      kind : PhiKind
      pattern : String
      placeholder : String
      confidence : Int
      enabled : Bool
      contextual : Bool
    } derive(Eq, 
    Debug    )

    A rule is deliberately data-shaped so downstream users can load or generate domain rules without changing the scanning pipeline.

    RuleIssue

    source
    pub(all) struct RuleIssue {
      rule_id : String
      message : String
    } derive(Eq, 
    Debug    )

    RuleLifecycle

    source
    pub enum RuleLifecycle {
      Stable
      Experimental
      Deprecated
    } derive(Eq, 
    Debug    )

    RulePack

    source
    pub(all) struct RulePack {
      name : String
      version : String
      locale : LocaleHint
      description : String
      rules : Array[Rule]
      lifecycle : RuleLifecycle
    } derive(Eq, 
    Debug    )

    RulePatch

    source
    pub(all) struct RulePatch {
      id : String
      enabled : Bool?
      confidence : Int?
      placeholder : String?
      label : String?
    } derive(Eq, 
    Debug    )

    RuleSpec

    source
    pub(all) struct RuleSpec {
      id : String
      label : String
      kind : PhiKind
      pattern : String
      placeholder : String
      confidence : Int
      contextual : Bool
    } derive(Eq, 
    Debug    )

    ScanStatistics

    source
    pub(all) struct ScanStatistics {
      input_length : Int
      rule_count : Int
      candidate_count : Int
      accepted_count : Int
      rejected_count : Int
      character_count : Int
      line_count : Int
      high_risk_count : Int
      critical_count : Int
    } derive(Eq, 
    Debug    )

    SectionKind

    source
    pub enum SectionKind {
      Demographics
      Contact
      Diagnosis
      Medication
      Laboratory
      Narrative
      Unknown
    } derive(Eq, 
    Debug    )

    SectionSummary

    source
    pub(all) struct SectionSummary {
      title : String
      kind : SectionKind
      finding_count : Int
      risk : RiskLevel
    } derive(Eq, 
    Debug    )

    Span

    source
    pub(all) struct Span {
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    A bounded half-open interval in the original document.

    Span::clamp

    source
    fn Span::clamp(self : Span, text_length : Int) -> Span

    Span::contains

    source
    fn Span::contains(self : Span, position : Int) -> Bool

    Span::contains_span

    source
    fn Span::contains_span(self : Span, other : Span) -> Bool

    Span::intersection

    source
    fn Span::intersection(self : Span, other : Span) -> Span?

    Span::is_empty

    source
    fn Span::is_empty(self : Span) -> Bool

    Span::is_valid

    source
    fn Span::is_valid(self : Span, text_length : Int) -> Bool

    Span::length

    source
    fn Span::length(self : Span) -> Int

    Span::overlaps

    source
    fn Span::overlaps(self : Span, other : Span) -> Bool

    Span::shift

    source
    fn Span::shift(self : Span, amount : Int) -> Span

    Span::touches

    source
    fn Span::touches(self : Span, other : Span) -> Bool

    SpanRelation

    source
    pub enum SpanRelation {
      Disjoint
      Touching
      LeftOverlap
      RightOverlap
      Contains
      ContainedBy
      Equal
    } derive(Eq, 
    Debug    )

    StreamingRedactor

    source
    pub(all) struct StreamingRedactor {
      config : RedactionConfig
      context_window : Int
      carry : String
      closed : Bool
    } derive(
    Debug    )

    StreamingRedactor::finish

    source
    fn StreamingRedactor::finish(self : StreamingRedactor) -> String raise DeidError

    StreamingRedactor::new

    source
    fn StreamingRedactor::new(config : RedactionConfig, context_window : Int) -> StreamingRedactor

    StreamingRedactor::push

    source
    fn StreamingRedactor::push(self : StreamingRedactor, chunk : String) -> String raise DeidError

    TextDifference

    source
    pub(all) struct TextDifference {
      start : Int
      end : Int
      original : String
      replacement : String
    } derive(Eq, 
    Debug    )

    TextToken

    source
    pub(all) struct TextToken {
      kind : String
      text : String
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    TextWindow

    source
    pub(all) struct TextWindow {
      start : Int
      end : Int
      text : String
    } derive(Eq, 
    Debug    )

    account_findings

    source
    fn account_findings(findings : Array[Finding]) -> Array[Finding]

    action_name

    source
    fn action_name(action : PolicyAction) -> String

    add_protected_range

    source
    fn add_protected_range(policy : RedactionPolicy, start : Int, end : Int, reason : String) -> RedactionPolicy

    address_components

    source
    fn address_components(value : String) -> Array[String]

    all_ascii_digits

    source
    fn all_ascii_digits(text : String) -> Bool

    all_ascii_hex

    source
    fn all_ascii_hex(text : String) -> Bool

    all_high_confidence

    source
    fn all_high_confidence(findings : Array[Finding], threshold : Int) -> Bool

    allow_only_kinds

    source
    fn allow_only_kinds(policy : RedactionPolicy, kinds : Array[PhiKind]) -> RedactionPolicy

    analytics_average_confidence

    source
    fn analytics_average_confidence(items : Array[DocumentAnalytics]) -> Float

    analytics_average_ratio

    source
    fn analytics_average_ratio(items : Array[DocumentAnalytics]) -> Float

    analytics_kind_totals

    source
    fn analytics_kind_totals(items : Array[DocumentAnalytics]) -> Map[String, Int]

    analytics_markdown

    source
    fn analytics_markdown(items : Array[DocumentAnalytics]) -> String

    analytics_max_risk

    source
    fn analytics_max_risk(items : Array[DocumentAnalytics]) -> DocumentAnalytics?

    analytics_min_risk

    source
    fn analytics_min_risk(items : Array[DocumentAnalytics]) -> DocumentAnalytics?

    analytics_risk_total

    source
    fn analytics_risk_total(items : Array[DocumentAnalytics]) -> Int

    analytics_summary

    source
    fn analytics_summary(items : Array[DocumentAnalytics]) -> String

    analytics_threshold

    source
    fn analytics_threshold(items : Array[DocumentAnalytics], risk : Int) -> Array[DocumentAnalytics]

    analytics_to_csv

    source
    fn analytics_to_csv(items : Array[DocumentAnalytics]) -> String

    analytics_to_json

    source
    fn analytics_to_json(items : Array[DocumentAnalytics]) -> String

    analytics_with_findings

    source
    fn analytics_with_findings(items : Array[DocumentAnalytics]) -> Array[DocumentAnalytics]

    analytics_without_findings

    source
    fn analytics_without_findings(items : Array[DocumentAnalytics]) -> Array[DocumentAnalytics]

    analyze_document

    source
    fn analyze_document(id : String, input : String, result : DeidResult) -> DocumentAnalytics

    analyze_documents

    source
    fn analyze_documents(items : Array[BatchItem], config : RedactionConfig) -> Array[DocumentAnalytics] raise DeidError

    api_surface_summary

    source
    fn api_surface_summary() -> String

    apply_confidence_floor

    source
    fn apply_confidence_floor(findings : Array[Finding], floor : Int) -> Array[Finding]

    apply_findings_with_mode

    source
    fn apply_findings_with_mode(input : String, findings : Array[Finding], mode : ReplacementMode) -> (String, Array[OffsetMap])

    apply_rule_patch

    source
    fn apply_rule_patch(item : Rule, patch : RulePatch) -> Rule

    apply_rule_patches

    source
    fn apply_rule_patches(rules : Array[Rule], patches : Array[RulePatch]) -> Array[Rule]

    ascii_digit_value

    source
    fn ascii_digit_value(c : Char) -> Int

    Convert an ASCII decimal character to a digit. Callers validate the input first; the fallback keeps validation functions total.

    ascii_lower

    source
    fn ascii_lower(text : String) -> String

    ascii_upper

    source
    fn ascii_upper(text : String) -> String

    audit_csv

    source
    fn audit_csv(report : AuditReport) -> String

    audit_default

    source
    fn audit_default(input : String) -> String raise DeidError

    audit_finding_ids

    source
    fn audit_finding_ids(report : AuditReport) -> Array[String]

    audit_for_external_review

    source
    fn audit_for_external_review(input : String, result : DeidResult) -> String

    audit_has_critical

    source
    fn audit_has_critical(report : AuditReport) -> Bool

    audit_has_kind

    source
    fn audit_has_kind(report : AuditReport, kind : PhiKind) -> Bool

    audit_has_rule

    source
    fn audit_has_rule(report : AuditReport, rule_id : String) -> Bool

    audit_is_empty

    source
    fn audit_is_empty(report : AuditReport) -> Bool

    audit_kind_count

    source
    fn audit_kind_count(report : AuditReport, kind : PhiKind) -> Int

    audit_markdown

    source
    fn audit_markdown(report : AuditReport) -> String

    audit_markdown_table

    source
    fn audit_markdown_table(report : AuditReport) -> String

    audit_offset_coverage

    source
    fn audit_offset_coverage(report : AuditReport) -> Int

    audit_plain_text

    source
    fn audit_plain_text(report : AuditReport) -> String

    audit_replacement_delta

    source
    fn audit_replacement_delta(report : AuditReport) -> Int

    audit_report_with_context

    source
    fn audit_report_with_context(input : String, report : AuditReport, radius : Int) -> String

    audit_risk_count

    source
    fn audit_risk_count(report : AuditReport, level : RiskLevel) -> Int

    audit_risk_level

    source
    fn audit_risk_level(report : AuditReport) -> RiskLevel

    audit_rule_ids

    source
    fn audit_rule_ids(report : AuditReport) -> Array[String]

    audit_summary

    source
    fn audit_summary(report : AuditReport) -> String

    audit_summary_json

    source
    fn audit_summary_json(report : AuditReport) -> String

    audit_summary_lines

    source
    fn audit_summary_lines(report : AuditReport) -> Array[String]

    audit_to_json

    source
    fn audit_to_json(report : AuditReport) -> String

    average_confidence

    source
    fn average_confidence(findings : Array[Finding]) -> Float

    average_finding_length

    source
    fn average_finding_length(findings : Array[Finding]) -> Float

    batch_audit_json

    source
    fn batch_audit_json(outcome : BatchOutcome) -> String

    batch_consistency_issues

    source
    fn batch_consistency_issues(outcome : BatchOutcome) -> Array[String]

    batch_contains_critical

    source
    fn batch_contains_critical(outcome : BatchOutcome) -> Bool

    batch_diagnostics_csv

    source
    fn batch_diagnostics_csv(outcome : BatchOutcome) -> String

    batch_failed_diagnostics

    source
    fn batch_failed_diagnostics(outcome : BatchOutcome) -> Array[BatchDiagnostic]

    batch_findings

    source
    fn batch_findings(results : Array[BatchResult]) -> Array[Finding]

    batch_ids

    source
    fn batch_ids(results : Array[BatchResult]) -> Array[String]

    batch_kind_counts

    source
    fn batch_kind_counts(results : Array[BatchResult]) -> Map[String, Int]

    batch_partition

    source
    fn batch_partition(items : Array[BatchItem], size : Int) -> Array[Array[BatchItem]]

    batch_risk_counts

    source
    fn batch_risk_counts(results : Array[BatchResult]) -> Map[String, Int]

    batch_success_ratio

    source
    fn batch_success_ratio(outcome : BatchOutcome) -> Float

    batch_total_applied

    source
    fn batch_total_applied(results : Array[BatchResult]) -> Int

    batch_total_findings

    source
    fn batch_total_findings(results : Array[BatchResult]) -> Int

    batch_totals

    source
    fn batch_totals(results : Array[BatchResult]) -> AuditTotals

    benchmark_case_by_name

    source
    fn benchmark_case_by_name(name : String) -> BenchmarkCase?

    benchmark_case_names

    source
    fn benchmark_case_names() -> Array[String]

    benchmark_case_summary

    source
    fn benchmark_case_summary(item : BenchmarkCase) -> String

    benchmark_cases

    source
    fn benchmark_cases() -> Array[BenchmarkCase]

    benchmark_catalog_summary

    source
    fn benchmark_catalog_summary() -> String

    benchmark_catalog_valid

    source
    fn benchmark_catalog_valid() -> Bool

    benchmark_findings_delta

    source
    fn benchmark_findings_delta(item : BenchmarkCase, result : BenchmarkResult) -> Int

    benchmark_fixture

    source
    fn benchmark_fixture() -> Array[String]

    benchmark_once

    source
    fn benchmark_once(name : String, documents : Array[String], repetitions : Int, config : RedactionConfig) -> BenchmarkResult raise DeidError

    benchmark_results_json

    source
    fn benchmark_results_json(results : Array[BenchmarkResult]) -> String

    benchmark_results_text

    source
    fn benchmark_results_text(results : Array[BenchmarkResult]) -> String

    benchmark_summary

    source
    fn benchmark_summary(result : BenchmarkResult) -> String

    benchmark_to_json

    source
    fn benchmark_to_json(result : BenchmarkResult) -> String

    boundary_after

    source
    fn boundary_after(text : String, position : Int) -> Bool

    boundary_before

    source
    fn boundary_before(text : String, position : Int) -> Bool

    build_mapping_index

    source
    fn build_mapping_index(input_length : Int, output_length : Int, findings : Array[Finding], offsets : Array[OffsetMap]) -> MappingIndex

    builtin_rules

    source
    fn builtin_rules() -> Array[Rule]

    Built-in rules cover common PHI in Chinese and English clinical notes. They intentionally favor precision over exhaustive recall.

    capabilities

    source
    fn capabilities() -> Map[String, Bool]

    capability_lines

    source
    fn capability_lines() -> Array[String]

    carry_for_boundary

    source
    fn carry_for_boundary(text : String, width : Int) -> String

    char_at_or

    source
    fn char_at_or(text : String, position : Int, fallback : Char) -> Char

    char_count

    source
    fn char_count(text : String) -> Int

    char_histogram

    source
    fn char_histogram(text : String) -> Map[String, Int]

    char_index_to_code_unit

    source
    fn char_index_to_code_unit(text : String, index : Int) -> Int

    char_span_to_code_units

    source
    fn char_span_to_code_units(text : String, span : Span) -> Span

    chars_to_string

    source
    fn chars_to_string(chars : Array[Char]) -> String

    Build a string from a character array without relying on a particular backend's string representation.

    checksum_mod11

    source
    fn checksum_mod11(values : Array[Int], weights : Array[Int]) -> Int?

    checksum_score

    source
    fn checksum_score(finding : Finding) -> Int

    chinese_rule_pack

    source
    fn chinese_rule_pack() -> RulePack

    chunk_policy_summary

    source
    fn chunk_policy_summary(policy : ChunkPolicy) -> String

    chunk_results_findings

    source
    fn chunk_results_findings(results : Array[ChunkResult]) -> Array[Finding]

    chunk_results_text

    source
    fn chunk_results_text(results : Array[ChunkResult], separator : String) -> String

    cjk_tokens

    source
    fn cjk_tokens(text : String) -> Array[TextToken]

    classify_section

    source
    fn classify_section(title : String) -> SectionKind

    code_unit_count

    source
    fn code_unit_count(text : String) -> Int

    code_unit_offsets

    source
    fn code_unit_offsets(text : String) -> Array[Int]

    code_unit_span_to_chars

    source
    fn code_unit_span_to_chars(text : String, span : Span) -> Span

    code_unit_to_char_index

    source
    fn code_unit_to_char_index(text : String, offset : Int) -> Int

    collapse_spaces

    source
    fn collapse_spaces(text : String) -> String

    compare_analytics

    source
    fn compare_analytics(left : DocumentAnalytics, right : DocumentAnalytics) -> AnalyticsComparison

    compare_results

    source
    fn compare_results(left : DeidResult, right : DeidResult) -> Map[String, Bool]

    compliance_boundary_notice

    source
    fn compliance_boundary_notice() -> String

    compose_rules

    source
    fn compose_rules(base : Array[Rule], additions : Array[Rule]) -> Array[Rule]

    comprehensive_rules

    source
    fn comprehensive_rules() -> Array[Rule]

    confidence_band

    source
    fn confidence_band(value : Int) -> ConfidenceBand

    confidence_band_name

    source
    fn confidence_band_name(band : ConfidenceBand) -> String

    confidence_histogram

    source
    fn confidence_histogram(findings : Array[Finding]) -> Map[String, Int]

    config_with_policy

    source
    fn config_with_policy(policy : RedactionPolicy) -> RedactionConfig

    config_with_salt

    source
    fn config_with_salt(salt : String) -> RedactionConfig

    contact_findings

    source
    fn contact_findings(findings : Array[Finding]) -> Array[Finding]

    contains_ascii_letter

    source
    fn contains_ascii_letter(text : String) -> Bool

    contains_cjk

    source
    fn contains_cjk(text : String) -> Bool

    contains_direct_identifier

    source
    fn contains_direct_identifier(findings : Array[Finding]) -> Bool

    contextual_rule

    source
    fn contextual_rule(id : String, label : String, kind : PhiKind, pattern : String, placeholder : String, confidence : Int) -> Rule

    contextual_score

    source
    fn contextual_score(input : String, finding : Finding, radius : Int) -> Int

    contract_to_json

    source
    fn contract_to_json(contract : RedactionContract) -> String

    contract_to_text

    source
    fn contract_to_text(contract : RedactionContract) -> String

    count_char

    source
    fn count_char(text : String, target : Char) -> Int

    count_substring

    source
    fn count_substring(text : String, needle : String) -> Int

    counts_as_sorted_lines

    source
    fn counts_as_sorted_lines(counts : Map[String, Int]) -> Array[String]

    cumulative_offset_delta

    source
    fn cumulative_offset_delta(offsets : Array[OffsetMap]) -> Array[Int]

    custom_rule

    source
    fn custom_rule(id : String, label : String, kind : PhiKind, pattern : String, placeholder : String, confidence : Int) -> Rule

    data_inventory

    source
    fn data_inventory(input : String, result : DeidResult) -> Map[String, Int]

    data_inventory_text

    source
    fn data_inventory_text(input : String, result : DeidResult) -> String

    date_digits

    source
    fn date_digits(value : String) -> String

    date_is_future

    source
    fn date_is_future(value : String, current_year : Int) -> Bool

    days_in_month

    source
    fn days_in_month(year : Int, month : Int) -> Int

    decimal_value

    source
    fn decimal_value(value : String) -> Int

    deduplicate_batch

    source
    fn deduplicate_batch(items : Array[BatchItem]) -> Array[BatchItem]

    deduplicate_rules

    source
    fn deduplicate_rules(rules : Array[Rule]) -> Array[Rule]

    default_placeholders

    source
    fn default_placeholders() -> PlaceholderRegistry

    default_rule_pack

    source
    fn default_rule_pack() -> RulePack

    deny_rules

    source
    fn deny_rules(policy : RedactionPolicy, rule_ids : Array[String]) -> RedactionPolicy

    diagnose_findings

    source
    fn diagnose_findings(input : String, findings : Array[Finding]) -> Array[Diagnostic]

    diagnose_policy

    source
    fn diagnose_policy(policy : RedactionPolicy, input_length : Int) -> Array[Diagnostic]

    diagnose_rule

    source
    fn diagnose_rule(rule : Rule) -> Array[Diagnostic]

    diagnose_rules

    source
    fn diagnose_rules(rules : Array[Rule]) -> Array[Diagnostic]

    diagnostic_count_by_severity

    source
    fn diagnostic_count_by_severity(items : Array[Diagnostic]) -> Map[String, Int]

    diagnostics_have_errors

    source
    fn diagnostics_have_errors(items : Array[Diagnostic]) -> Bool

    diagnostics_summary

    source
    fn diagnostics_summary(items : Array[Diagnostic]) -> String

    diagnostics_to_json

    source
    fn diagnostics_to_json(items : Array[Diagnostic]) -> String

    diagnostics_to_text

    source
    fn diagnostics_to_text(items : Array[Diagnostic]) -> String

    differences_to_json

    source
    fn differences_to_json(differences : Array[TextDifference]) -> String

    differences_to_markdown

    source
    fn differences_to_markdown(differences : Array[TextDifference]) -> String

    direct_findings

    source
    fn direct_findings(findings : Array[Finding]) -> Array[Finding]

    disable_rules_by_kind

    source
    fn disable_rules_by_kind(rules : Array[Rule], kind : PhiKind) -> Array[Rule]

    disabled_rule_ids

    source
    fn disabled_rule_ids(rules : Array[Rule]) -> Array[String]

    display_width

    source
    fn display_width(text : String) -> Int

    document_diagnostics

    source
    fn document_diagnostics(input : String, policy : RedactionPolicy, rules : Array[Rule]) -> Array[Diagnostic] raise DeidError

    email_domain

    source
    fn email_domain(value : String) -> String

    email_local_part

    source
    fn email_local_part(value : String) -> String

    empty_result

    source
    fn empty_result(input : String) -> DeidResult

    enable_rules_above

    source
    fn enable_rules_above(rules : Array[Rule], confidence : Int) -> Array[Rule]

    enabled_rules

    source
    fn enabled_rules(rules : Array[Rule]) -> Array[Rule]

    ends_with_word

    source
    fn ends_with_word(text : String, suffix : String) -> Bool

    english_rule_pack

    source
    fn english_rule_pack() -> RulePack

    entities_for_kind

    source
    fn entities_for_kind(batch : EntityBatch, kind : PhiKind) -> Array[EntityInput]

    entities_for_source

    source
    fn entities_for_source(batch : EntityBatch, source : String) -> Array[EntityInput]

    entity_batch

    source
    fn entity_batch(source : String, entities : Array[EntityInput]) -> EntityBatch

    entity_batch_from_tsv

    source
    fn entity_batch_from_tsv(text : String, source : String) -> EntityBatch

    entity_batch_is_clean

    source
    fn entity_batch_is_clean(input : String, batch : EntityBatch) -> Bool

    entity_batch_overlap_count

    source
    fn entity_batch_overlap_count(batch : EntityBatch) -> Int

    entity_batch_summary

    source
    fn entity_batch_summary(batch : EntityBatch) -> String

    entity_batch_to_external

    source
    fn entity_batch_to_external(batch : EntityBatch) -> Array[ExternalEntity]

    entity_batch_to_tsv

    source
    fn entity_batch_to_tsv(batch : EntityBatch) -> String

    entity_confidence_average

    source
    fn entity_confidence_average(batch : EntityBatch) -> Float

    entity_input

    source
    fn entity_input(label~ : String, kind~ : PhiKind, start~ : Int, end~ : Int, confidence~ : Int, source~ : String) -> EntityInput

    entity_kind_counts

    source
    fn entity_kind_counts(batch : EntityBatch) -> Map[String, Int]

    entity_source_counts

    source
    fn entity_source_counts(batch : EntityBatch) -> Map[String, Int]

    entity_spans

    source
    fn entity_spans(batch : EntityBatch) -> Array[Span]

    evaluate_cases

    source
    fn evaluate_cases(cases : Array[EvaluationCase], rules? : Array[Rule]) -> EvaluationResult raise DeidError

    evaluate_one_case

    source
    fn evaluate_one_case(case : EvaluationCase, predicted : Array[Finding]) -> EvaluationResult

    evaluate_synthetic_cases

    source
    fn evaluate_synthetic_cases() -> EvaluationResult raise DeidError

    evaluation_summary

    source
    fn evaluation_summary(result : EvaluationResult) -> String

    evaluation_to_json

    source
    fn evaluation_to_json(result : EvaluationResult) -> String

    exact_span_match

    source
    fn exact_span_match(left : Span, right : Span) -> Bool

    explain_risk

    source
    fn explain_risk(kind : PhiKind) -> String

    explain_text

    source
    fn explain_text(input : String, config : RedactionConfig) -> String raise DeidError

    extended_rules

    source
    fn extended_rules() -> Array[Rule]

    Additional deterministic rules for outpatient notes, laboratory records, insurance forms, and mixed Chinese-English exports.

    external_entities_csv

    source
    fn external_entities_csv(entities : Array[ExternalEntity]) -> String

    external_entity

    source
    fn external_entity(item : EntityInput) -> ExternalEntity

    f1_score

    source
    fn f1_score(result : EvaluationResult) -> Float

    field_keys

    source
    fn field_keys(fields : Array[FieldValue]) -> Array[String]

    field_map

    source
    fn field_map(fields : Array[FieldValue]) -> Map[String, String]

    field_name_counts

    source
    fn field_name_counts(fields : Array[FieldValue]) -> Map[String, Int]

    field_report

    source
    fn field_report(text : String) -> String

    field_values

    source
    fn field_values(fields : Array[FieldValue], key : String) -> Array[String]

    field_values_length

    source
    fn field_values_length(fields : Array[FieldValue]) -> Int

    fields_containing_phi

    source
    fn fields_containing_phi(fields : Array[FieldValue], config : RedactionConfig) -> Array[String] raise DeidError

    fields_named

    source
    fn fields_named(fields : Array[FieldValue], key : String) -> Array[FieldValue]

    filter_findings_by_confidence

    source
    fn filter_findings_by_confidence(findings : Array[Finding], threshold : Int) -> Array[Finding]

    filter_findings_by_kind

    source
    fn filter_findings_by_kind(findings : Array[Finding], kinds : Array[PhiKind]) -> Array[Finding]

    filter_protected_findings

    source
    fn filter_protected_findings(findings : Array[Finding], protected_ranges : Array[ProtectedRange]) -> Array[Finding]

    finding_context

    source
    fn finding_context(input : String, finding : Finding, radius : Int) -> TextWindow

    finding_density

    source
    fn finding_density(findings : Array[Finding], input_length : Int) -> Float

    finding_ids

    source
    fn finding_ids(findings : Array[Finding]) -> Array[String]

    finding_intersects_any

    source
    fn finding_intersects_any(finding : Finding, spans : Array[Span]) -> Bool

    finding_is_valid

    source
    fn finding_is_valid(finding : Finding, input_length : Int) -> Bool

    finding_kind_counts

    source
    fn finding_kind_counts(findings : Array[Finding]) -> Map[String, Int]

    finding_length

    source
    fn finding_length(finding : Finding) -> Int

    finding_replacements

    source
    fn finding_replacements(findings : Array[Finding]) -> Array[String]

    finding_risk_counts

    source
    fn finding_risk_counts(findings : Array[Finding]) -> Map[String, Int]

    finding_rule_counts

    source
    fn finding_rule_counts(findings : Array[Finding]) -> Map[String, Int]

    finding_score

    source
    fn finding_score(finding : Finding) -> Int

    finding_span

    source
    fn finding_span(finding : Finding) -> Span

    finding_texts

    source
    fn finding_texts(findings : Array[Finding]) -> Array[String]

    finding_to_json

    source
    fn finding_to_json(finding : Finding) -> String

    findings_csv

    source
    fn findings_csv(findings : Array[Finding]) -> String

    findings_for_kind

    source
    fn findings_for_kind(findings : Array[Finding], kind : PhiKind) -> Array[Finding]

    findings_for_rule

    source
    fn findings_for_rule(findings : Array[Finding], rule_id : String) -> Array[Finding]

    findings_in_span

    source
    fn findings_in_span(findings : Array[Finding], window : Span) -> Array[Finding]

    findings_overlapping_span

    source
    fn findings_overlapping_span(findings : Array[Finding], window : Span) -> Array[Finding]

    findings_to_spans

    source
    fn findings_to_spans(findings : Array[Finding]) -> Array[Span]

    findings_with_mode

    source
    fn findings_with_mode(findings : Array[Finding], mode : ReplacementMode) -> Array[Finding]

    findings_with_placeholders

    source
    fn findings_with_placeholders(findings : Array[Finding], registry : PlaceholderRegistry) -> Array[Finding]

    first_char

    source
    fn first_char(text : String) -> Char?

    first_field

    source
    fn first_field(fields : Array[FieldValue], key : String) -> FieldValue?

    first_finding

    source
    fn first_finding(findings : Array[Finding]) -> Finding?

    has_sensitive_keyword

    source
    fn has_sensitive_keyword(text : String) -> Bool

    high_precision_rule_pack

    source
    fn high_precision_rule_pack() -> RulePack

    high_risk_findings

    source
    fn high_risk_findings(findings : Array[Finding]) -> Array[Finding]

    highest_risk

    source
    fn highest_risk(findings : Array[Finding]) -> RiskLevel

    identifier_class

    source
    fn identifier_class(value : String) -> String

    identifier_entropy_hint

    source
    fn identifier_entropy_hint(value : String) -> Int

    identifier_is_reversible

    source
    fn identifier_is_reversible(value : String, kind : IdentifierKind) -> Bool

    identifier_kind_name

    source
    fn identifier_kind_name(kind : IdentifierKind) -> String

    identifier_kind_values

    source
    fn identifier_kind_values() -> Array[IdentifierKind]

    identifier_quality

    source
    fn identifier_quality(value : String) -> Int

    inverse_position_through_offsets

    source
    fn inverse_position_through_offsets(offsets : Array[OffsetMap], position : Int) -> Int

    is_ascii_alphanumeric_char

    source
    fn is_ascii_alphanumeric_char(c : Char) -> Bool

    is_ascii_char

    source
    fn is_ascii_char(c : Char) -> Bool

    is_ascii_digit_char

    source
    fn is_ascii_digit_char(c : Char) -> Bool

    is_ascii_letter_char

    source
    fn is_ascii_letter_char(c : Char) -> Bool

    is_ascii_punctuation_char

    source
    fn is_ascii_punctuation_char(c : Char) -> Bool

    is_blank_char

    source
    fn is_blank_char(c : Char) -> Bool

    is_cjk_char

    source
    fn is_cjk_char(c : Char) -> Bool

    is_hex_char

    source
    fn is_hex_char(c : Char) -> Bool

    is_leap_year

    source
    fn is_leap_year(year : Int) -> Bool

    is_surrogate_code_unit

    source
    fn is_surrogate_code_unit(unit : UInt16) -> Bool

    is_word_boundary

    source
    fn is_word_boundary(text : String, start : Int, end : Int) -> Bool

    is_word_char

    source
    fn is_word_char(c : Char) -> Bool

    json_escape

    source
    fn json_escape(text : String) -> String

    json_span

    source
    fn json_span(span : Span) -> String

    keep_ascii_letters_and_digits

    source
    fn keep_ascii_letters_and_digits(text : String) -> String

    keep_digits

    source
    fn keep_digits(text : String) -> String

    keyword_findings

    source
    fn keyword_findings(text : String) -> Array[Finding]

    kind_coverage

    source
    fn kind_coverage(findings : Array[Finding], expected : Array[PhiKind]) -> Float

    labeled_value_findings

    source
    fn labeled_value_findings(text : String) -> Array[Finding] raise DeidError

    last_char

    source
    fn last_char(text : String) -> Char?

    last_finding

    source
    fn last_finding(findings : Array[Finding]) -> Finding?

    length_histogram

    source
    fn length_histogram(findings : Array[Finding]) -> Map[String, Int]

    lexical_score

    source
    fn lexical_score(finding : Finding) -> Int

    line_column

    source
    fn line_column(text : String, offset : Int) -> LineColumn

    line_count

    source
    fn line_count(text : String) -> Int

    line_findings

    source
    fn line_findings(text : String) -> Map[Int, Array[Finding]] raise DeidError

    literal_findings

    source
    fn literal_findings(text : String, needles : Array[String], kind : PhiKind, label : String, rule_id : String, confidence : Int) -> Array[Finding]

    literal_occurrences

    source
    fn literal_occurrences(text : String, needles : Array[String]) -> Array[Span]

    locale_name

    source
    fn locale_name(locale : LocaleHint) -> String

    long_synthetic_note

    source
    fn long_synthetic_note(repetitions : Int) -> String

    longest_common_prefix

    source
    fn longest_common_prefix(left : String, right : String) -> String

    longest_token

    source
    fn longest_token(tokens : Array[TextToken]) -> TextToken?

    make_manifest

    source
    fn make_manifest(document_id : String, input : String, result : DeidResult, pack : RulePack, generated_at : String) -> ProcessingManifest

    manifest_checksum

    source
    fn manifest_checksum(manifest : ProcessingManifest) -> String

    manifest_csv

    source
    fn manifest_csv(manifests : Array[ProcessingManifest]) -> String

    manifest_is_consistent

    source
    fn manifest_is_consistent(manifest : ProcessingManifest, result : DeidResult) -> Bool

    manifest_to_json

    source
    fn manifest_to_json(manifest : ProcessingManifest) -> String

    map_position_through_offsets

    source
    fn map_position_through_offsets(offsets : Array[OffsetMap], position : Int) -> Int

    map_to_json

    source
    fn map_to_json(values : Map[String, Int]) -> String

    mapping_from_result

    source
    fn mapping_from_result(result : DeidResult) -> MappingIndex

    mapping_segment

    source
    fn mapping_segment(finding : Finding, offset : OffsetMap) -> MappingSegment

    mask_identifier

    source
    fn mask_identifier(value : String, kind : IdentifierKind) -> String

    mask_value

    source
    fn mask_value(value : String, mode : ReplacementMode) -> String

    match_qualities

    source
    fn match_qualities(input : String, findings : Array[Finding], radius : Int) -> Array[MatchQuality]

    match_quality

    source
    fn match_quality(input : String, finding : Finding, radius : Int) -> MatchQuality

    match_quality_report

    source
    fn match_quality_report(input : String, findings : Array[Finding], radius : Int) -> String

    maximum_confidence

    source
    fn maximum_confidence(findings : Array[Finding]) -> Int

    merge_adjacent_tokens

    source
    fn merge_adjacent_tokens(tokens : Array[TextToken]) -> Array[TextToken]

    merge_audit_totals

    source
    fn merge_audit_totals(left : AuditTotals, right : AuditTotals) -> AuditTotals

    merge_batch_outcomes

    source
    fn merge_batch_outcomes(left : BatchOutcome, right : BatchOutcome) -> BatchOutcome

    merge_entity_batch

    source
    fn merge_entity_batch(input : String, findings : Array[Finding], batch : EntityBatch, mode : ReplacementMode) -> Array[Finding]

    merge_external_entities

    source
    fn merge_external_entities(input : String, findings : Array[Finding], entities : Array[ExternalEntity], mode? : ReplacementMode) -> Array[Finding]

    merge_rule_packs

    source
    fn merge_rule_packs(left : RulePack, right : RulePack) -> RulePack

    merge_spans

    source
    fn merge_spans(spans : Array[Span]) -> Array[Span]

    minimum_confidence

    source
    fn minimum_confidence(findings : Array[Finding]) -> Int

    mode_name

    source
    fn mode_name(mode : ReplacementMode) -> String

    modes_preview

    source
    fn modes_preview(input : String) -> Map[String, String] raise DeidError

    name_initials

    source
    fn name_initials(value : String) -> String

    nearest_finding

    source
    fn nearest_finding(findings : Array[Finding], position : Int) -> Finding?

    nearest_safe_boundary

    source
    fn nearest_safe_boundary(text : String, offset : Int) -> Int

    neighboring_tokens

    source
    fn neighboring_tokens(tokens : Array[TextToken], index : Int, radius : Int) -> Array[TextToken]

    ner_merge_and_redact

    source
    fn ner_merge_and_redact(input : String, batch : EntityBatch, mode : ReplacementMode) -> DeidResult

    non_space_tokens

    source
    fn non_space_tokens(tokens : Array[TextToken]) -> Array[TextToken]

    normalize_address

    source
    fn normalize_address(value : String) -> String

    normalize_date

    source
    fn normalize_date(value : String) -> String?

    normalize_email

    source
    fn normalize_email(value : String) -> String

    normalize_entity_batch

    source
    fn normalize_entity_batch(input : String, batch : EntityBatch) -> EntityBatch

    normalize_for_matching

    source
    fn normalize_for_matching(text : String) -> String

    normalize_identifier

    source
    fn normalize_identifier(value : String, kind : IdentifierKind) -> String

    normalize_newlines

    source
    fn normalize_newlines(text : String) -> String

    normalize_phone

    source
    fn normalize_phone(value : String) -> String

    normalize_punctuation

    source
    fn normalize_punctuation(text : String) -> String

    normalize_rule_confidence

    source
    fn normalize_rule_confidence(item : Rule) -> Rule

    normalize_rules

    source
    fn normalize_rules(rules : Array[Rule]) -> Array[Rule]

    normalize_with_offset_notice

    source
    fn normalize_with_offset_notice(text : String) -> (String, Bool)

    normalized_identifier

    source
    fn normalized_identifier(value : String) -> String

    number_tokens

    source
    fn number_tokens(text : String) -> Array[TextToken]

    numeric_prefix

    source
    fn numeric_prefix(text : String) -> String

    numeric_suffix

    source
    fn numeric_suffix(text : String) -> String

    offset_delta

    source
    fn offset_delta(offset : OffsetMap) -> Int

    offset_to_json

    source
    fn offset_to_json(offset : OffsetMap) -> String

    offsets_are_monotonic

    source
    fn offsets_are_monotonic(offsets : Array[OffsetMap]) -> Bool

    output_change_ratio

    source
    fn output_change_ratio(result : DeidResult) -> Float

    output_contains_original_identifier

    source
    fn output_contains_original_identifier(result : DeidResult) -> Bool

    output_contract_issues

    source
    fn output_contract_issues(input : String, result : DeidResult) -> Array[String]

    output_contract_passes

    source
    fn output_contract_passes(input : String, result : DeidResult) -> Bool

    output_is_redacted

    source
    fn output_is_redacted(result : DeidResult) -> Bool

    overlap_pairs

    source
    fn overlap_pairs(findings : Array[Finding]) -> Array[(String, String)]

    overlap_span_match

    source
    fn overlap_span_match(left : Span, right : Span) -> Bool

    pack_checksum

    source
    fn pack_checksum(pack : RulePack) -> String

    pack_disable_rule

    source
    fn pack_disable_rule(pack : RulePack, id : String) -> RulePack

    pack_disabled_rules

    source
    fn pack_disabled_rules(pack : RulePack) -> Array[Rule]

    pack_enable_rule

    source
    fn pack_enable_rule(pack : RulePack, id : String) -> RulePack

    pack_enabled_rules

    source
    fn pack_enabled_rules(pack : RulePack) -> Array[Rule]

    pack_filter_confidence

    source
    fn pack_filter_confidence(pack : RulePack, minimum : Int) -> RulePack

    pack_filter_kind

    source
    fn pack_filter_kind(pack : RulePack, kind : PhiKind) -> RulePack

    pack_has_rule

    source
    fn pack_has_rule(pack : RulePack, id : String) -> Bool

    pack_is_valid

    source
    fn pack_is_valid(pack : RulePack) -> Bool

    pack_replace_rule

    source
    fn pack_replace_rule(pack : RulePack, replacement : Rule) -> RulePack

    pack_round_trip_text

    source
    fn pack_round_trip_text(pack : RulePack) -> Bool

    pack_rule

    source
    fn pack_rule(pack : RulePack, id : String) -> Rule?

    pack_rule_ids

    source
    fn pack_rule_ids(pack : RulePack) -> Array[String]

    pack_summary

    source
    fn pack_summary(pack : RulePack) -> String

    pack_to_text

    source
    fn pack_to_text(pack : RulePack) -> String

    pack_validate

    source
    fn pack_validate(pack : RulePack) -> Array[RuleIssue]

    pack_with_lifecycle

    source
    fn pack_with_lifecycle(pack : RulePack, lifecycle : RuleLifecycle) -> RulePack

    package_capability_report

    source
    fn package_capability_report() -> String

    package_name

    source
    fn package_name() -> String

    packs_have_disjoint_ids

    source
    fn packs_have_disjoint_ids(left : RulePack, right : RulePack) -> Bool

    pad_left

    source
    fn pad_left(text : String, width : Int, fill : Char) -> String

    pad_right

    source
    fn pad_right(text : String, width : Int, fill : Char) -> String

    parse_compact_date

    source
    fn parse_compact_date(value : String) -> (Int, Int, Int)?

    parse_delimited_row

    source
    fn parse_delimited_row(text : String, delimiter : Char) -> Array[FieldValue]

    parse_field_line

    source
    fn parse_field_line(line : String, offset : Int) -> FieldValue?

    parse_fields

    source
    fn parse_fields(text : String) -> Array[FieldValue]

    partial_options

    source
    fn partial_options(min_confidence? : Int) -> DeidOptions

    phi_kind_name

    source
    fn phi_kind_name(kind : PhiKind) -> String

    phone_region_hint

    source
    fn phone_region_hint(value : String) -> String

    pipeline_findings

    source
    fn pipeline_findings(result : PipelineResult) -> Array[Finding]

    pipeline_for_profile

    source
    fn pipeline_for_profile(input : String, profile : Profile, mode : ReplacementMode) -> PipelineResult raise DeidError

    pipeline_has_errors

    source
    fn pipeline_has_errors(result : PipelineResult) -> Bool

    pipeline_is_safe

    source
    fn pipeline_is_safe(result : PipelineResult) -> Bool

    pipeline_replay

    source
    fn pipeline_replay(input : String, result : PipelineResult) -> Bool raise DeidError

    pipeline_stage_name

    source
    fn pipeline_stage_name(stage : PipelineStage) -> String

    pipeline_summary

    source
    fn pipeline_summary(result : PipelineResult) -> String

    pipeline_to_json

    source
    fn pipeline_to_json(result : PipelineResult) -> String

    pipeline_trace_checksum

    source
    fn pipeline_trace_checksum(result : PipelineResult) -> String

    pipeline_trace_text

    source
    fn pipeline_trace_text(trace : Array[PipelineTrace]) -> String

    pipeline_with_policy

    source
    fn pipeline_with_policy(input : String, policy : RedactionPolicy) -> PipelineResult raise DeidError

    policy_allows_kind

    source
    fn policy_allows_kind(policy : RedactionPolicy, kind : PhiKind) -> Bool

    policy_blocks_rule

    source
    fn policy_blocks_rule(policy : RedactionPolicy, rule_id : String) -> Bool

    policy_decisions

    source
    fn policy_decisions(findings : Array[Finding], policy : RedactionPolicy) -> Array[PolicyDecision]

    policy_decisions_to_csv

    source
    fn policy_decisions_to_csv(decisions : Array[PolicyDecision]) -> String

    policy_filter_findings

    source
    fn policy_filter_findings(findings : Array[Finding], policy : RedactionPolicy) -> Array[Finding]

    policy_protects

    source
    fn policy_protects(policy : RedactionPolicy, finding : Finding) -> Bool

    policy_summary

    source
    fn policy_summary(policy : RedactionPolicy) -> String

    precision

    source
    fn precision(result : EvaluationResult) -> Float

    preserve_length_options

    source
    fn preserve_length_options(min_confidence? : Int) -> DeidOptions

    preview_redaction

    source
    fn preview_redaction(input : String, config : RedactionConfig) -> Array[Finding] raise DeidError

    preview_text

    source
    fn preview_text(input : String, config : RedactionConfig) -> String raise DeidError

    privacy_class

    source
    fn privacy_class(kind : PhiKind) -> PrivacyClass

    privacy_class_counts

    source
    fn privacy_class_counts(findings : Array[Finding]) -> Map[String, Int]

    privacy_class_name

    source
    fn privacy_class_name(class : PrivacyClass) -> String

    privacy_summary

    source
    fn privacy_summary(findings : Array[Finding]) -> PrivacySummary

    privacy_summary_to_map

    source
    fn privacy_summary_to_map(summary : PrivacySummary) -> Map[String, Int]

    probable_address

    source
    fn probable_address(value : String) -> Bool

    probable_chinese_name

    source
    fn probable_chinese_name(value : String) -> Bool

    probable_english_name

    source
    fn probable_english_name(value : String) -> Bool

    profile_redaction

    source
    fn profile_redaction(input : String, profile : Profile, mode : ReplacementMode) -> DeidResult raise DeidError

    profile_rules

    source
    fn profile_rules(profile : Profile) -> Array[Rule]

    protected_range

    source
    fn protected_range(start~ : Int, end~ : Int, reason~ : String) -> ProtectedRange

    pseudonym_for

    source
    fn pseudonym_for(value : String, kind : IdentifierKind, salt : String) -> String

    pseudonym_map

    source
    fn pseudonym_map(values : Array[String], kind : IdentifierKind, salt : String) -> Map[String, String]

    punctuation_tokens

    source
    fn punctuation_tokens(text : String) -> Array[TextToken]

    quality_adjust_confidence

    source
    fn quality_adjust_confidence(input : String, finding : Finding, radius : Int) -> Finding

    quality_adjust_findings

    source
    fn quality_adjust_findings(input : String, findings : Array[Finding], radius : Int) -> Array[Finding]

    quality_average

    source
    fn quality_average(qualities : Array[MatchQuality]) -> Float

    quality_by_finding

    source
    fn quality_by_finding(qualities : Array[MatchQuality]) -> Map[String, Int]

    quality_by_kind

    source
    fn quality_by_kind(input : String, findings : Array[Finding], radius : Int) -> Map[String, Float]

    quality_consistency_issues

    source
    fn quality_consistency_issues(input : String, findings : Array[Finding]) -> Array[String]

    quality_filter_findings

    source
    fn quality_filter_findings(input : String, findings : Array[Finding], threshold : Int, radius : Int) -> Array[Finding]

    quality_is_consistent

    source
    fn quality_is_consistent(input : String, finding : Finding) -> Bool

    quality_minimum

    source
    fn quality_minimum(qualities : Array[MatchQuality]) -> Int

    quality_report

    source
    fn quality_report(input : String, result : DeidResult) -> String

    quasi_findings

    source
    fn quasi_findings(findings : Array[Finding]) -> Array[Finding]

    quote_for_log

    source
    fn quote_for_log(text : String) -> String

    recall

    source
    fn recall(result : EvaluationResult) -> Float

    redact

    source
    fn redact(input : String, rules? : Array[Rule], options? : DeidOptions) -> DeidResult raise DeidError

    redact_and_audit_csv

    source
    fn redact_and_audit_csv(input : String, config : RedactionConfig) -> String raise DeidError

    redact_and_audit_json

    source
    fn redact_and_audit_json(input : String, config : RedactionConfig) -> String raise DeidError

    redact_and_audit_markdown

    source
    fn redact_and_audit_markdown(input : String, config : RedactionConfig) -> String raise DeidError

    redact_batch

    source
    fn redact_batch(items : Array[BatchItem], rules? : Array[Rule], options? : DeidOptions) -> Array[BatchResult] raise DeidError

    redact_batch_with_config

    source
    fn redact_batch_with_config(items : Array[BatchItem], batch_config : BatchConfig, rules? : Array[Rule]) -> BatchOutcome raise DeidError

    redact_chinese_note

    source
    fn redact_chinese_note(input : String) -> DeidResult raise DeidError

    redact_chunk_results

    source
    fn redact_chunk_results(items : Array[BatchItem], config : RedactionConfig) -> Array[ChunkResult] raise DeidError

    redact_chunks

    source
    fn redact_chunks(chunks : Array[String], policy : ChunkPolicy) -> String raise DeidError

    redact_clinical_note

    source
    fn redact_clinical_note(input : String) -> DeidResult raise DeidError

    redact_csv_row

    source
    fn redact_csv_row(input : String, config : RedactionConfig) -> String raise DeidError

    redact_default

    source
    fn redact_default(input : String) -> DeidResult raise DeidError

    redact_delimited_row

    source
    fn redact_delimited_row(text : String, delimiter : Char, config : RedactionConfig) -> String raise DeidError

    redact_document_sections

    source
    fn redact_document_sections(input : String, config : RedactionConfig) -> String raise DeidError

    redact_english_note

    source
    fn redact_english_note(input : String) -> DeidResult raise DeidError

    redact_except_kinds

    source
    fn redact_except_kinds(input : String, excluded : Array[PhiKind], mode : ReplacementMode) -> DeidResult raise DeidError

    redact_field_values

    source
    fn redact_field_values(fields : Array[FieldValue], config : RedactionConfig) -> Array[FieldValue] raise DeidError

    redact_fields

    source
    fn redact_fields(text : String, config : RedactionConfig) -> String raise DeidError

    redact_high_precision

    source
    fn redact_high_precision(input : String) -> DeidResult raise DeidError

    redact_in_fixed_chunks

    source
    fn redact_in_fixed_chunks(input : String, width : Int, config : RedactionConfig) -> String raise DeidError

    redact_in_lines

    source
    fn redact_in_lines(input : String, config : RedactionConfig) -> String raise DeidError

    redact_key_value_document

    source
    fn redact_key_value_document(input : String, config : RedactionConfig) -> String raise DeidError

    redact_lines

    source
    fn redact_lines(text : String, config : RedactionConfig) -> Array[String] raise DeidError

    redact_lines_joined

    source
    fn redact_lines_joined(text : String, config : RedactionConfig, separator : String) -> String raise DeidError

    redact_named_fields

    source
    fn redact_named_fields(text : String, names : Array[String], config : RedactionConfig) -> String raise DeidError

    redact_only_kinds

    source
    fn redact_only_kinds(input : String, kinds : Array[PhiKind], mode : ReplacementMode) -> DeidResult raise DeidError

    redact_prefix

    source
    fn redact_prefix(input : String, length : Int, config : RedactionConfig) -> DeidResult raise DeidError

    redact_range

    source
    fn redact_range(input : String, range : Span, config : RedactionConfig) -> DeidResult raise DeidError

    redact_sections

    source
    fn redact_sections(text : String, config : RedactionConfig) -> String raise DeidError

    redact_strict_clinical_note

    source
    fn redact_strict_clinical_note(input : String) -> DeidResult raise DeidError

    redact_suffix

    source
    fn redact_suffix(input : String, length : Int, config : RedactionConfig) -> DeidResult raise DeidError

    redact_texts

    source
    fn redact_texts(texts : Array[String], config : RedactionConfig) -> Array[String] raise DeidError

    redact_token_candidates

    source
    fn redact_token_candidates(text : String, kind : PhiKind, config : RedactionConfig) -> String

    redact_tsv_row

    source
    fn redact_tsv_row(input : String, config : RedactionConfig) -> String raise DeidError

    redact_unicode_safe

    source
    fn redact_unicode_safe(input : String, config : RedactionConfig) -> DeidResult raise DeidError

    redact_until_stable

    source
    fn redact_until_stable(input : String, config : RedactionConfig, maximum_rounds : Int) -> DeidResult raise DeidError

    redact_windowed

    source
    fn redact_windowed(input : String, radius : Int, config : RedactionConfig) -> DeidResult raise DeidError

    redact_with_allowlist

    source
    fn redact_with_allowlist(input : String, protected_spans : Array[Span], config : RedactionConfig) -> DeidResult raise DeidError

    redact_with_config

    source
    fn redact_with_config(input : String, config : RedactionConfig, rules? : Array[Rule]) -> DeidResult raise DeidError

    redact_with_deny_rules

    source
    fn redact_with_deny_rules(input : String, denied_rule_ids : Array[String], config : RedactionConfig) -> DeidResult raise DeidError

    redact_with_kind_prefixes

    source
    fn redact_with_kind_prefixes(input : String, prefix : String) -> DeidResult raise DeidError

    redact_with_manifest

    source
    fn redact_with_manifest(document_id : String, input : String, config : RedactionConfig, generated_at : String) -> (DeidResult, ProcessingManifest) raise DeidError

    redact_with_placeholders

    source
    fn redact_with_placeholders(input : String, registry : PlaceholderRegistry) -> DeidResult raise DeidError

    redact_with_policy

    source
    fn redact_with_policy(input : String, policy : RedactionPolicy, rules? : Array[Rule]) -> DeidResult raise DeidError

    redact_with_profile

    source
    fn redact_with_profile(input : String, profile : Profile, mode : ReplacementMode) -> DeidResult raise DeidError

    redact_with_protected_fields

    source
    fn redact_with_protected_fields(input : String, protected_fields : Array[String], config : RedactionConfig) -> String raise DeidError

    redact_with_pseudonyms

    source
    fn redact_with_pseudonyms(input : String, salt : String) -> DeidResult raise DeidError

    redact_with_salt

    source
    fn redact_with_salt(input : String, salt : String, rules? : Array[Rule]) -> DeidResult raise DeidError

    redactable_char_count

    source
    fn redactable_char_count(text : String) -> Int

    redacted_text

    source
    fn redacted_text(input : String) -> String raise DeidError

    redaction_candidates_from_tokens

    source
    fn redaction_candidates_from_tokens(text : String, tokens : Array[TextToken], rule_id : String, kind : PhiKind, confidence : Int) -> Array[Finding]

    redaction_changed_text

    source
    fn redaction_changed_text(input : String, result : DeidResult) -> String

    redaction_findings

    source
    fn redaction_findings(input : String) -> Array[Finding] raise DeidError

    redaction_is_idempotent

    source
    fn redaction_is_idempotent(input : String, config : RedactionConfig) -> Bool raise DeidError

    redaction_offsets

    source
    fn redaction_offsets(input : String) -> Array[OffsetMap] raise DeidError

    redaction_preserves_newlines

    source
    fn redaction_preserves_newlines(input : String, result : DeidResult) -> Bool

    redaction_preserves_separators

    source
    fn redaction_preserves_separators(input : String, result : DeidResult, separators : String) -> Bool

    redaction_ratio

    source
    fn redaction_ratio(result : DeidResult) -> Float

    redaction_summary

    source
    fn redaction_summary(input : String, result : DeidResult) -> String

    registry_placeholders

    source
    fn registry_placeholders(registry : PlaceholderRegistry, kinds : Array[PhiKind]) -> Map[String, String]

    relabel_findings

    source
    fn relabel_findings(findings : Array[Finding], label_prefix : String) -> Array[Finding]

    remove_rules_by_id

    source
    fn remove_rules_by_id(rules : Array[Rule], ids : Array[String]) -> Array[Rule]

    remove_zero_width_chars

    source
    fn remove_zero_width_chars(text : String) -> String

    render_delimited_row

    source
    fn render_delimited_row(fields : Array[FieldValue], delimiter : String) -> String

    render_fields

    source
    fn render_fields(fields : Array[FieldValue], newline : String) -> String

    repeated_char

    source
    fn repeated_char(c : Char, count : Int) -> String

    replace_rule_by_id

    source
    fn replace_rule_by_id(rules : Array[Rule], replacement : Rule) -> Array[Rule]

    replace_token

    source
    fn replace_token(tokens : Array[TextToken], index : Int, value : String) -> Array[TextToken]

    replacement_boundary_is_safe

    source
    fn replacement_boundary_is_safe(text : String, offset : Int) -> Bool

    replacement_dictionary

    source
    fn replacement_dictionary(findings : Array[Finding]) -> Map[String, String]

    replacement_dictionary_checksum

    source
    fn replacement_dictionary_checksum(findings : Array[Finding]) -> String

    replacement_for_finding

    source
    fn replacement_for_finding(finding : Finding, mode : ReplacementMode) -> String

    replacement_preview

    source
    fn replacement_preview(finding : Finding, mode : ReplacementMode) -> String

    report_checksum

    source
    fn report_checksum(report : AuditReport) -> String

    report_is_deterministic

    source
    fn report_is_deterministic(left : AuditReport, right : AuditReport) -> Bool

    result_change_count

    source
    fn result_change_count(result : DeidResult) -> Int

    result_contract

    source
    fn result_contract(input : String, result : DeidResult) -> RedactionContract

    result_contract_report

    source
    fn result_contract_report(input : String, result : DeidResult) -> String

    result_delta

    source
    fn result_delta(result : DeidResult) -> Int

    result_differences

    source
    fn result_differences(input : String, result : DeidResult) -> Array[TextDifference]

    result_findings_between

    source
    fn result_findings_between(result : DeidResult, start : Int, end : Int) -> Array[Finding]

    result_for_mode

    source
    fn result_for_mode(input : String, mode : ReplacementMode) -> DeidResult raise DeidError

    result_has_kind

    source
    fn result_has_kind(result : DeidResult, kind : PhiKind) -> Bool

    result_has_replacement

    source
    fn result_has_replacement(result : DeidResult, replacement : String) -> Bool

    result_has_stable_mapping

    source
    fn result_has_stable_mapping(result : DeidResult) -> Bool

    result_integrity_score

    source
    fn result_integrity_score(input : String, result : DeidResult) -> Float

    result_is_safe

    source
    fn result_is_safe(input : String) -> Bool raise DeidError

    result_mapping_description

    source
    fn result_mapping_description(result : DeidResult) -> String

    result_matches_text

    source
    fn result_matches_text(result : DeidResult, expected : String) -> Bool

    result_original_coverage

    source
    fn result_original_coverage(result : DeidResult) -> Int

    result_output_coverage

    source
    fn result_output_coverage(result : DeidResult) -> Int

    result_replacement_kinds

    source
    fn result_replacement_kinds(result : DeidResult) -> Array[String]

    result_replay_checksum

    source
    fn result_replay_checksum(result : DeidResult) -> String

    result_text_window

    source
    fn result_text_window(result : DeidResult, center : Int, radius : Int) -> TextWindow

    result_to_json

    source
    fn result_to_json(result : DeidResult) -> String

    retention_summary

    source
    fn retention_summary(policy : RetentionPolicy) -> String

    review_clinical_note

    source
    fn review_clinical_note(input : String) -> DeidResult raise DeidError

    risk_level

    source
    fn risk_level(finding : Finding) -> RiskLevel

    risk_score

    source
    fn risk_score(findings : Array[Finding]) -> Int

    risk_score_per_character

    source
    fn risk_score_per_character(findings : Array[Finding], input_length : Int) -> Float

    risk_summary

    source
    fn risk_summary(findings : Array[Finding]) -> Map[String, Int]

    rule_confidence_histogram

    source
    fn rule_confidence_histogram(rules : Array[Rule]) -> Map[String, Int]

    rule_count_by_kind

    source
    fn rule_count_by_kind(rules : Array[Rule]) -> Map[String, Int]

    rule_counts_report

    source
    fn rule_counts_report() -> String

    rule_diff

    source
    fn rule_diff(left : Array[Rule], right : Array[Rule]) -> Array[String]

    rule_from_spec

    source
    fn rule_from_spec(spec : RuleSpec) -> Rule

    rule_ids

    source
    fn rule_ids(rules : Array[Rule]) -> Array[String]

    rule_ids_with_prefix

    source
    fn rule_ids_with_prefix(rules : Array[Rule], prefix : String) -> Array[String]

    rule_lifecycle_name

    source
    fn rule_lifecycle_name(lifecycle : RuleLifecycle) -> String

    rule_lifecycle_values

    source
    fn rule_lifecycle_values() -> Array[RuleLifecycle]

    rule_pack

    source
    fn rule_pack(name~ : String, version~ : String, locale~ : LocaleHint, description~ : String, rules~ : Array[Rule]) -> RulePack

    rule_pack_with_patches

    source
    fn rule_pack_with_patches(pack : RulePack, patches : Array[RulePatch]) -> RulePack

    rule_patch

    source
    fn rule_patch(id~ : String, enabled? : Bool, confidence? : Int, placeholder? : String, label? : String) -> RulePatch

    rule_recommendation

    source
    fn rule_recommendation(rule : Rule) -> String

    rule_recommendations

    source
    fn rule_recommendations(rules : Array[Rule]) -> Map[String, String]

    rule_spec

    source
    fn rule_spec(id~ : String, label~ : String, kind~ : PhiKind, pattern~ : String, placeholder~ : String, confidence~ : Int, contextual? : Bool) -> RuleSpec

    rule_spec_from_rule

    source
    fn rule_spec_from_rule(item : Rule) -> RuleSpec

    rule_surface_report

    source
    fn rule_surface_report(rules : Array[Rule]) -> String

    rules_above_confidence

    source
    fn rules_above_confidence(rules : Array[Rule], threshold : Int) -> Array[Rule]

    rules_checksum

    source
    fn rules_checksum(rules : Array[Rule]) -> String

    rules_for_kind

    source
    fn rules_for_kind(rules : Array[Rule], kind : PhiKind) -> Array[Rule]

    rules_for_locale

    source
    fn rules_for_locale(rules : Array[Rule], locale : LocaleHint) -> Array[Rule]

    rules_to_tsv

    source
    fn rules_to_tsv(rules : Array[Rule]) -> String

    run_all_benchmarks

    source
    fn run_all_benchmarks(repetitions : Int, config : RedactionConfig) -> Array[BenchmarkResult] raise DeidError

    run_benchmark_case

    source
    fn run_benchmark_case(item : BenchmarkCase, repetitions : Int, config : RedactionConfig) -> BenchmarkResult raise DeidError

    run_pipeline

    source
    fn run_pipeline(input : String, config : PipelineConfig) -> PipelineResult raise DeidError

    safe_audit_export

    source
    fn safe_audit_export(report : AuditReport, retention : RetentionPolicy) -> String

    safe_char_slice

    source
    fn safe_char_slice(text : String, start : Int, end : Int) -> String

    safe_code_unit_boundaries

    source
    fn safe_code_unit_boundaries(text : String) -> Array[Int]

    safe_default_contract

    source
    fn safe_default_contract(input : String) -> Bool raise DeidError

    safe_export_contract

    source
    fn safe_export_contract(input : String, result : DeidResult) -> Array[String]

    safe_finding_export

    source
    fn safe_finding_export(findings : Array[Finding], retention : RetentionPolicy) -> String

    safe_normalized_input

    source
    fn safe_normalized_input(text : String) -> String

    safe_slice_by_code_units

    source
    fn safe_slice_by_code_units(text : String, start : Int, end : Int) -> String

    safe_text_export

    source
    fn safe_text_export(result : DeidResult, retention : RetentionPolicy) -> String

    sanitize_input

    source
    fn sanitize_input(text : String) -> String

    sanitize_log_batch

    source
    fn sanitize_log_batch(messages : Array[String], config : RedactionConfig) -> Array[String] raise DeidError

    sanitize_log_message

    source
    fn sanitize_log_message(message : String, config : RedactionConfig) -> String raise DeidError

    scan

    source
    fn scan(input : String, rules? : Array[Rule], options? : DeidOptions) -> Array[Finding] raise DeidError

    scan_clinical_note

    source
    fn scan_clinical_note(input : String) -> Array[Finding] raise DeidError

    scan_default

    source
    fn scan_default(input : String) -> Array[Finding] raise DeidError

    scan_high_precision

    source
    fn scan_high_precision(input : String) -> Array[Finding] raise DeidError

    scan_statistics

    source
    fn scan_statistics(input : String, rules : Array[Rule], findings : Array[Finding]) -> ScanStatistics

    scan_statistics_for

    source
    fn scan_statistics_for(input : String, rules? : Array[Rule]) -> ScanStatistics raise DeidError

    scan_texts

    source
    fn scan_texts(texts : Array[String], rules : Array[Rule]) -> Array[Array[Finding]] raise DeidError

    scan_with_profile

    source
    fn scan_with_profile(input : String, profile : Profile) -> Array[Finding] raise DeidError

    schema_description

    source
    fn schema_description() -> String

    section_findings

    source
    fn section_findings(_text : String, section : DocumentSection) -> Array[Finding] raise DeidError

    section_kind_name

    source
    fn section_kind_name(kind : SectionKind) -> String

    section_risk

    source
    fn section_risk(text : String, section : DocumentSection) -> RiskLevel raise DeidError

    section_summaries

    source
    fn section_summaries(_text : String, sections : Array[DocumentSection]) -> Array[SectionSummary] raise DeidError

    section_summary_markdown

    source
    fn section_summary_markdown(summaries : Array[SectionSummary]) -> String

    sectionize

    source
    fn sectionize(text : String) -> Array[DocumentSection]

    sections_of_kind

    source
    fn sections_of_kind(sections : Array[DocumentSection], kind : SectionKind) -> Array[DocumentSection]

    select_pack

    source
    fn select_pack(profile : Profile) -> RulePack

    sensitive_line_count

    source
    fn sensitive_line_count(text : String) -> Int raise DeidError

    severity_name

    source
    fn severity_name(severity : DiagnosticSeverity) -> String

    shift_findings

    source
    fn shift_findings(findings : Array[Finding], amount : Int) -> Array[Finding]

    sort_findings

    source
    fn sort_findings(findings : Array[Finding]) -> Array[Finding]

    sort_findings_by_priority

    source
    fn sort_findings_by_priority(findings : Array[Finding]) -> Array[Finding]

    source_policy_notice

    source
    fn source_policy_notice() -> String

    span

    source
    fn span(start~ : Int, end~ : Int) -> Span

    span_relation

    source
    fn span_relation(left : Span, right : Span) -> SpanRelation

    span_summary

    source
    fn span_summary(spans : Array[Span]) -> String

    split_findings_by_risk

    source
    fn split_findings_by_risk(findings : Array[Finding]) -> (Array[Finding], Array[Finding], Array[Finding])

    split_fixed_chunks

    source
    fn split_fixed_chunks(text : String, width : Int) -> Array[String]

    split_lines_with_offsets

    source
    fn split_lines_with_offsets(text : String) -> Array[TextWindow]

    split_on_blank_lines

    source
    fn split_on_blank_lines(text : String) -> Array[String]

    stable_hash_options

    source
    fn stable_hash_options(min_confidence? : Int) -> DeidOptions

    stable_result_checksum

    source
    fn stable_result_checksum(result : DeidResult) -> String

    starts_with_word

    source
    fn starts_with_word(text : String, prefix : String) -> Bool

    stream_has_sensitive_boundary

    source
    fn stream_has_sensitive_boundary(text : String, rules : Array[Rule]) -> Bool raise DeidError

    string_has_non_bmp

    source
    fn string_has_non_bmp(text : String) -> Bool

    structural_score

    source
    fn structural_score(finding : Finding) -> Int

    subtract_span

    source
    fn subtract_span(source : Span, blocked : Array[Span]) -> Array[Span]

    subtract_spans

    source
    fn subtract_spans(sources : Array[Span], blocked : Array[Span]) -> Array[Span]

    summarize_batch

    source
    fn summarize_batch(results : Array[BatchResult]) -> BatchSummary

    summarize_texts

    source
    fn summarize_texts(texts : Array[String], config : RedactionConfig) -> Array[String] raise DeidError

    supported_exports

    source
    fn supported_exports() -> Array[String]

    supported_modes

    source
    fn supported_modes() -> Array[String]

    supported_profiles

    source
    fn supported_profiles() -> Array[String]

    supported_targets

    source
    fn supported_targets() -> Array[String]

    synthetic_evaluation_cases

    source
    fn synthetic_evaluation_cases() -> Array[EvaluationCase]

    text_window

    source
    fn text_window(text : String, center : Int, radius : Int) -> TextWindow

    token_after

    source
    fn token_after(tokens : Array[TextToken], position : Int) -> TextToken?

    token_before

    source
    fn token_before(tokens : Array[TextToken], position : Int) -> TextToken?

    token_char_counts

    source
    fn token_char_counts(tokens : Array[TextToken]) -> Map[String, Int]

    token_context

    source
    fn token_context(text : String, token : TextToken, radius : Int) -> TextWindow

    token_count

    source
    fn token_count(text : String) -> Int

    token_kind_at

    source
    fn token_kind_at(tokens : Array[TextToken], position : Int) -> String?

    token_kind_counts

    source
    fn token_kind_counts(tokens : Array[TextToken]) -> Map[String, Int]

    token_lengths

    source
    fn token_lengths(tokens : Array[TextToken]) -> Array[Int]

    token_options

    source
    fn token_options(min_confidence? : Int) -> DeidOptions

    token_positions

    source
    fn token_positions(tokens : Array[TextToken]) -> Array[LineColumn]

    token_reconstruct

    source
    fn token_reconstruct(tokens : Array[TextToken]) -> String

    token_spans

    source
    fn token_spans(tokens : Array[TextToken]) -> Array[Span]

    token_texts

    source
    fn token_texts(tokens : Array[TextToken]) -> Array[String]

    tokenization_is_lossless

    source
    fn tokenization_is_lossless(text : String) -> Bool

    tokenization_report

    source
    fn tokenization_report(text : String) -> String

    tokenize

    source
    fn tokenize(text : String) -> Array[TextToken]

    tokens_in_span

    source
    fn tokens_in_span(tokens : Array[TextToken], span : Span) -> Array[TextToken]

    tokens_of_kind

    source
    fn tokens_of_kind(tokens : Array[TextToken], kind : String) -> Array[TextToken]

    total_finding_length

    source
    fn total_finding_length(findings : Array[Finding]) -> Int

    trim_ascii_space

    source
    fn trim_ascii_space(text : String) -> String

    unchanged_text

    source
    fn unchanged_text(input : String, result : DeidResult) -> String

    unicode_profile

    source
    fn unicode_profile(text : String) -> Map[String, Int]

    unicode_profile_text

    source
    fn unicode_profile_text(text : String) -> String

    unique_findings

    source
    fn unique_findings(findings : Array[Finding]) -> Array[Finding]

    unique_kind_count

    source
    fn unique_kind_count(findings : Array[Finding]) -> Int

    unique_rule_count

    source
    fn unique_rule_count(findings : Array[Finding]) -> Int

    valid_accession

    source
    fn valid_accession(value : String) -> Bool

    valid_bank_card

    source
    fn valid_bank_card(value : String) -> Bool

    valid_calendar_date

    source
    fn valid_calendar_date(year : Int, month : Int, day : Int) -> Bool

    valid_chinese_id

    source
    fn valid_chinese_id(value : String) -> Bool

    valid_email_address

    source
    fn valid_email_address(value : String) -> Bool

    valid_entity_input

    source
    fn valid_entity_input(input : String, item : EntityInput) -> Bool

    valid_hex_color

    source
    fn valid_hex_color(value : String) -> Bool

    valid_iban_prefix

    source
    fn valid_iban_prefix(value : String) -> Bool

    valid_imei

    source
    fn valid_imei(value : String) -> Bool

    valid_ipv4

    source
    fn valid_ipv4(value : String) -> Bool

    valid_lab_code

    source
    fn valid_lab_code(value : String) -> Bool

    valid_luhn

    source
    fn valid_luhn(value : String) -> Bool

    valid_mac_address

    source
    fn valid_mac_address(value : String) -> Bool

    valid_month

    source
    fn valid_month(month : Int) -> Bool

    valid_passport_number

    source
    fn valid_passport_number(value : String) -> Bool

    valid_phone_number

    source
    fn valid_phone_number(value : String) -> Bool

    valid_postal_code

    source
    fn valid_postal_code(value : String, locale : LocaleHint) -> Bool

    valid_uuid

    source
    fn valid_uuid(value : String) -> Bool

    validate_finding_order

    source
    fn validate_finding_order(findings : Array[Finding]) -> Bool

    validate_finding_text

    source
    fn validate_finding_text(input : String, finding : Finding) -> Bool

    validate_findings

    source
    fn validate_findings(input : String, findings : Array[Finding]) -> Array[String]

    validate_rule

    source
    fn validate_rule(rule : Rule) -> Array[RuleIssue]

    validate_rules

    source
    fn validate_rules(rules : Array[Rule]) -> Array[RuleIssue]

    version

    source
    fn version() -> String

    whitespace_spans

    source
    fn whitespace_spans(text : String) -> Array[Span]

    with_policy_confidence

    source
    fn with_policy_confidence(policy : RedactionPolicy, min_confidence : Int) -> RedactionPolicy

    with_policy_locale

    source
    fn with_policy_locale(policy : RedactionPolicy, locale : LocaleHint) -> RedactionPolicy

    with_policy_mode

    source
    fn with_policy_mode(policy : RedactionPolicy, mode : ReplacementMode) -> RedactionPolicy

    word_tokens

    source
    fn word_tokens(text : String) -> Array[TextToken]

    workload_summary

    source
    fn workload_summary(documents : Array[String]) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io