🥮 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
moon add ljlljl678/moonbit-deid@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
2 hours ago
Downloads
2

Dependencies

README

#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