@blindfold/sdk 1.0.2

package/dist/index-Dfv8zV_d.d.ts

@@ -0,0 +1,177 @@
+//#region src/regex/entities.d.ts
+/**
+ * PII entity types detected by the regex scanner.
+ * Names match the Blindfold API entity types for transparent switching.
+ */
+declare enum EntityType {
+  EMAIL_ADDRESS = "Email Address",
+  CREDIT_CARD = "Credit Card Number",
+  PHONE_NUMBER = "Phone Number",
+  IP_ADDRESS = "IP Address",
+  URL = "URL",
+  MAC_ADDRESS = "MAC Address",
+  DATE_OF_BIRTH = "Date of Birth",
+  CVV = "CVV",
+  SSN = "Social Security Number",
+  DRIVERS_LICENSE = "Driver's License",
+  US_PASSPORT = "US Passport",
+  TAX_ID = "Tax ID",
+  ZIP_CODE = "ZIP Code",
+  IBAN = "IBAN",
+  EU_POSTAL_CODE = "Postal Code",
+  VAT_ID = "VAT ID",
+  NI_NUMBER = "NI Number",
+  NHS_NUMBER = "NHS Number",
+  UK_POSTCODE = "UK Postcode",
+  UK_PASSPORT = "UK Passport",
+  DE_PERSONAL_ID = "German Personal ID",
+  DE_TAX_ID = "German Tax ID",
+  FR_NATIONAL_ID = "French National ID",
+  ES_DNI = "Spanish DNI",
+  ES_NIE = "Spanish NIE",
+  IT_CODICE_FISCALE = "Italian Codice Fiscale",
+  PT_NIF = "Portuguese NIF",
+  PL_PESEL = "Polish PESEL",
+  PL_NIP = "Polish NIP",
+  CZ_BIRTH_NUMBER = "Czech Birth Number",
+  CZ_ICO = "Czech ICO",
+  CZ_DIC = "Czech DIC",
+  CZ_BANK_ACCOUNT = "Czech Bank Account",
+  RU_INN = "Russian INN",
+  RU_SNILS = "Russian SNILS",
+  NL_BSN = "Dutch BSN",
+  RO_CNP = "Romanian CNP",
+  SK_BIRTH_NUMBER = "Slovak Birth Number",
+  DK_CPR = "Danish CPR",
+  SE_PERSONNUMMER = "Swedish Personnummer",
+  NO_BIRTH_NUMBER = "Norwegian Birth Number",
+  BR_CPF = "Brazilian CPF",
+  BR_CNPJ = "Brazilian CNPJ",
+  US_ITIN = "US ITIN",
+  UK_UTR = "UK UTR",
+  FR_SIREN = "French SIREN",
+  ES_NSS = "Spanish NSS",
+  ES_CIF = "Spanish CIF",
+  IT_PARTITA_IVA = "Italian Partita IVA",
+  PL_REGON = "Polish REGON",
+  SK_ICO = "Slovak ICO",
+  SK_DIC = "Slovak DIC",
+  RO_CUI = "Romanian CUI",
+  DK_CVR = "Danish CVR",
+  SE_ORGNR = "Swedish Organisationsnummer",
+  NO_ORGNR = "Norwegian Organisasjonsnummer",
+  BE_NATIONAL_NUMBER = "Belgian National Number",
+  BE_ENTERPRISE_NUMBER = "Belgian Enterprise Number",
+  AT_SVNR = "Austrian SVNR",
+  IE_PPS = "Irish PPS Number",
+  FI_HETU = "Finnish HETU",
+  FI_YTUNNUS = "Finnish Y-tunnus",
+  HU_TAX_ID = "Hungarian Tax ID",
+  HU_TAJ = "Hungarian TAJ",
+  BG_EGN = "Bulgarian EGN",
+  HR_OIB = "Croatian OIB",
+  SI_EMSO = "Slovenian EMSO",
+  SI_TAX_NUMBER = "Slovenian Tax Number",
+  LT_PERSONAL_CODE = "Lithuanian Personal Code",
+  LV_PERSONAL_CODE = "Latvian Personal Code",
+  EE_PERSONAL_CODE = "Estonian Personal Code",
+  CA_SIN = "Canadian SIN",
+  CH_AHV = "Swiss AHV",
+  AU_TFN = "Australian TFN",
+  AU_MEDICARE = "Australian Medicare",
+  NZ_IRD = "New Zealand IRD",
+  IN_AADHAAR = "Indian Aadhaar",
+  IN_PAN = "Indian PAN",
+  JP_MY_NUMBER = "Japanese My Number",
+  KR_RRN = "Korean RRN",
+  ZA_ID = "South African ID",
+  TR_KIMLIK = "Turkish Kimlik",
+  IL_ID = "Israeli ID",
+  AR_CUIT = "Argentine CUIT",
+  CL_RUT = "Chilean RUT",
+  CO_NIT = "Colombian NIT",
+}
+/** A single PII match found by a detector. */
+interface PIIMatch {
+  entityType: string;
+  text: string;
+  start: number;
+  end: number;
+  score: number;
+} //#endregion
+//#region src/regex/scanner.d.ts
+
+//# sourceMappingURL=entities.d.ts.map
+interface PIIScannerOptions {
+  /** List of locale codes to enable (default: ["us"]). */
+  locales?: string[];
+}
+interface TokenizeResult {
+  text: string;
+  mapping: Record<string, string>;
+  matches: PIIMatch[];
+}
+interface MaskResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface HashResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface EncryptResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface SynthesizeResult {
+  text: string;
+  matches: PIIMatch[];
+}
+/**
+ * Local regex-based PII scanner.
+ *
+ * Usage:
+ *   const scanner = new PIIScanner({ locales: ['us', 'eu'] })
+ *   const matches = scanner.detect('Email john@acme.com, SSN 123-45-6789')
+ *   const [redacted, matches] = scanner.redact('Email john@acme.com')
+ */
+declare class PIIScanner {
+  private registry;
+  constructor(options?: PIIScannerOptions);
+  /** Detect PII entities in text and return deduplicated matches. */
+  detect(text: string, entities?: string[]): PIIMatch[];
+  /**
+   * Detect and remove PII from text.
+   * Returns a tuple of [redactedText, detectedMatches].
+   */
+  redact(text: string, entities?: string[]): [string, PIIMatch[]];
+  /**
+   * Detect PII and replace with numbered tokens like `<Email Address_1>`.
+   * Returns tokenized text, a mapping from tokens to original values, and matches.
+   */
+  tokenize(text: string, entities?: string[]): TokenizeResult;
+  /**
+   * Detect PII and partially mask each match.
+   */
+  mask(text: string, charsToShow?: number, fromEnd?: boolean, maskingChar?: string, entities?: string[]): MaskResult;
+  /**
+   * Detect PII and replace each match with a deterministic hash.
+   */
+  hash(text: string, hashType?: string, hashPrefix?: string, hashLength?: number, entities?: string[]): HashResult;
+  /**
+   * Detect PII and encrypt each match with AES-256-CBC.
+   * @param encryptionKey - Required, minimum 16 characters.
+   */
+  encrypt(text: string, encryptionKey: string, entities?: string[]): EncryptResult;
+  /**
+   * Detect PII and replace each match with format-preserving synthetic data.
+   * @param _language - Accepted for API compatibility but ignored locally.
+   */
+  synthesize(text: string, _language?: string, entities?: string[]): SynthesizeResult;
+  /** Remove overlapping matches, preferring higher score then longer span. */
+  private deduplicate;
+} //#endregion
+
+//# sourceMappingURL=scanner.d.ts.map
+export { EntityType, PIIMatch, PIIScanner, PIIScannerOptions };
+//# sourceMappingURL=index-Dfv8zV_d.d.ts.map

package/dist/index-Dfv8zV_d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dfv8zV_d.d.ts","names":[],"sources":["../src/regex/entities.ts","../src/regex/scanner.ts"],"sourcesContent":null,"mappings":";;;;;aAMY,UAAA;EAAA,aAAU,GAAA,eAAA;;EAqML,YAAQ,GAAA,cAAA;;;;ECjMR,aAAA,GAAA,eAAiB;EAKjB,GAAA,GAAA,KAAA;EAAc,GAAA,GAAA,wBAAA;EAAA,eAEpB,GAAA,kBAAA;EAAM,WACN,GAAA,aAAA;EAAQ,MAAA,GAAA,QAAA;EAGF,QAAA,GAAA,UAAU;EAKV,IAAA,GAAA,MAAU;EAKV,cAAA,GAAa,aAEnB;EAGM,MAAA,GAAA,QAAA;;;;;;;;;EAaJ,MAAA,GAAA,aAAU;EAAA,iBAAA,GAAA,wBAAA;EAAA,MAGC,GAAA,gBAAA;EAAiB,QAKI,GAAA,cAAA;EAAQ,MAwBC,GAAA,YAAA;EAAQ,eAsBf,GAAA,oBAAA;EAAc,MAwCxD,GAAA,WAAA;EAAU,MAiCV,GAAA,WAAA;EAAU,eAsBsD,GAAA,oBAAA;EAAa,MA+Bb,GAAA,aAAA;EAAgB,QAAA,GAAA,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UD1BpE,QAAA;;;;;;;;;;UCjMA,iBAAA;;;ADJjB;UCSiB,cAAA;ED4LA,IAAA,EAAA,MAAQ;WC1Ld;WACA;;AARM,UAWA,UAAA,CAXiB;EAKjB,IAAA,EAAA,MAAA;EAAc,OAAA,EAQpB,QARoB,EAAA;;AAGpB,UAQM,UAAA,CARN;EAAQ,IAAA,EAAA,MAAA;EAGF,OAAA,EAON,QAPgB,EAAA;AAK3B;AAKiB,UAAA,aAAA,CAEN;EAGM,IAAA,EAAA,MAAA;WAHN;;UAGM,gBAAA;;WAEN;;;;AAWX;;;;;;AA8FK,cA9FQ,UAAA,CA8FR;EAAU,QAiCV,QAAA;EAAU,WAsBsD,CAAA,OAAA,CAAA,EAlJ7C,iBAkJ6C;EAAa;EA+BG,MAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EAAA,MAAA,EAAA,CAAA,EA5KxC,QA4KwC,EAAA;;;;;sDApJ/B;;;;;+CAsBP;;;;0GAwC1C;;;;wGAiCA;;;;;qEAsBgE;;;;;qEA+BA"}

package/dist/index.d.mts

@@ -0,0 +1,450 @@
+import { EntityType$1 as EntityType, PIIMatch, PIIScanner$1 as PIIScanner } from "./index-CsE6Vhax.mjs";
+
+//#region src/types.d.ts
+/**
+* Configuration for Blindfold client
+*/
+/**
+ * Configuration for Blindfold client
+ */
+interface BlindfoldConfig {
+  /** API key for authentication. When omitted, detect() and redact() use the local regex scanner. */
+  apiKey?: string;
+  /** Base URL for the API (default: https://api.blindfold.dev/api/public/v1) */
+  baseUrl?: string;
+  /** Region for data residency ("eu" or "us"). Overrides baseUrl if baseUrl is not set. */
+  region?: 'eu' | 'us';
+  /** Optional user ID to track who is making the request */
+  userId?: string;
+  /** Maximum number of retries on transient errors (default: 2, 0 to disable) */
+  maxRetries?: number;
+  /** Initial delay in seconds before first retry (default: 0.5) */
+  retryDelay?: number;
+  /** Set to "local" to force local regex detection even when an API key is present. */
+  mode?: 'local' | 'api';
+  /** Locale codes for the local regex scanner (default: ["us"]). Example: ["us", "eu", "cz"]. Only used in local mode. */
+  locales?: string[];
+  /** Path to a JSON file with custom policy definitions. Merged over the bundled policies. */
+  policiesFile?: string;
+}
+/**
+ * Configuration options for tokenization
+ */
+interface TokenizeConfig {
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Configuration options for detection (no text transformation)
+ */
+interface DetectConfig {
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from detect endpoint
+ */
+interface DetectResponse {
+  /** List of detected entities */
+  detected_entities: DetectedEntity[];
+  /** Count of detected entities */
+  entities_count: number;
+}
+/**
+ * Detected entity information
+ */
+interface DetectedEntity {
+  /** Entity type (e.g., "person", "email address", "phone number") */
+  type: string;
+  /** Original text of the entity */
+  text: string;
+  /** Start index in text */
+  start: number;
+  /** End index in text */
+  end: number;
+  /** Confidence score (0-1) */
+  score: number;
+}
+/**
+ * Response from tokenize endpoint
+ */
+interface TokenizeResponse {
+  /** Anonymized text with placeholders */
+  text: string;
+  /** Mapping of tokens to original values */
+  mapping: Record<string, string>;
+  /** List of detected entities */
+  detected_entities: DetectedEntity[];
+  /** Count of detected entities */
+  entities_count: number;
+}
+/**
+ * Response from detokenize endpoint
+ */
+interface DetokenizeResponse {
+  /** Original text with restored values */
+  text: string;
+  /** Number of replacements made */
+  replacements_made: number;
+}
+/**
+ * Configuration options for redaction
+ */
+interface RedactConfig {
+  /** Character(s) to use for masking (default: "*") */
+  masking_char?: string;
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from redact endpoint
+ */
+interface RedactResponse {
+  /** Text with PII permanently removed */
+  text: string;
+  /** List of detected and redacted entities */
+  detected_entities: DetectedEntity[];
+  /** Number of entities redacted */
+  entities_count: number;
+}
+/**
+ * Configuration options for masking
+ */
+interface MaskConfig {
+  /** Number of characters to show (default: 3) */
+  chars_to_show?: number;
+  /** Whether to show characters from the end (default: false) */
+  from_end?: boolean;
+  /** Character to use for masking (default: "*") */
+  masking_char?: string;
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from mask endpoint
+ */
+interface MaskResponse {
+  /** Text with PII partially masked */
+  text: string;
+  /** List of detected and masked entities */
+  detected_entities: DetectedEntity[];
+  /** Number of entities masked */
+  entities_count: number;
+}
+/**
+ * Configuration options for synthesis
+ */
+interface SynthesizeConfig {
+  /** Language code for synthetic data generation (e.g., 'en', 'cs', 'de') */
+  language?: string;
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from synthesis endpoint
+ */
+interface SynthesizeResponse {
+  /** Text with synthetic fake data */
+  text: string;
+  /** List of detected and synthesized entities */
+  detected_entities: DetectedEntity[];
+  /** Number of entities synthesized */
+  entities_count: number;
+}
+/**
+ * Configuration options for hashing
+ */
+interface HashConfig {
+  /** Hash algorithm to use (e.g., 'md5', 'sha1', 'sha256', 'sha512') */
+  hash_type?: string;
+  /** Prefix to add before hash value (default: 'HASH_') */
+  hash_prefix?: string;
+  /** Length of hash to display (default: 16) */
+  hash_length?: number;
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from hash endpoint
+ */
+interface HashResponse {
+  /** Text with PII replaced by hash values */
+  text: string;
+  /** List of detected and hashed entities */
+  detected_entities: DetectedEntity[];
+  /** Number of entities hashed */
+  entities_count: number;
+}
+/**
+ * Configuration options for encryption
+ */
+interface EncryptConfig {
+  /** Optional encryption key (if not provided, tenant key will be used) */
+  encryption_key?: string;
+  /** List of entities to detect */
+  entities?: string[];
+  /** Minimum confidence score for entity detection (0.0-1.0) */
+  score_threshold?: number;
+  /** Policy name to use for detection configuration (e.g., 'gdpr_eu', 'hipaa_us', 'basic') */
+  policy?: string;
+}
+/**
+ * Response from encrypt endpoint
+ */
+interface EncryptResponse {
+  /** Text with PII encrypted */
+  text: string;
+  /** List of detected and encrypted entities */
+  detected_entities: DetectedEntity[];
+  /** Number of entities encrypted */
+  entities_count: number;
+}
+/**
+ * Response wrapper for batch processing
+ */
+interface BatchResponse {
+  /** Array of individual results (or { error: string } for failed items) */
+  results: Record<string, unknown>[];
+  /** Total number of texts submitted */
+  total: number;
+  /** Number of texts processed successfully */
+  succeeded: number;
+  /** Number of texts that failed processing */
+  failed: number;
+}
+/**
+ * Error response from API
+ */
+interface APIErrorResponse {
+  detail?: string;
+  message?: string;
+} //#endregion
+//#region src/client.d.ts
+
+//# sourceMappingURL=types.d.ts.map
+/**
+ * Blindfold client for tokenization and detokenization.
+ *
+ * When no `apiKey` is provided, all methods run locally using the
+ * built-in regex PII scanner.  Set `mode: "local"` to force local
+ * mode even when an API key is present.
+ */
+declare class Blindfold {
+  private apiKey?;
+  private baseUrl;
+  private userId?;
+  private maxRetries;
+  private retryDelay;
+  private mode?;
+  private locales?;
+  private policies;
+  private _scanner?;
+  /**
+   * Create a new Blindfold client
+   * @param config - Configuration options. Can be omitted entirely for local-only mode.
+   */
+  constructor(config?: BlindfoldConfig);
+  private get useLocal();
+  private getScanner;
+  private resolvePolicy;
+  private retryWait;
+  /**
+   * Make an authenticated request to the API
+   */
+  private request;
+  /**
+   * Tokenize text by replacing sensitive information with tokens
+   * @param text - Text to tokenize
+   * @param config - Optional configuration
+   * @returns Promise with tokenized text and mapping
+   */
+  tokenize(text: string, config?: TokenizeConfig): Promise<TokenizeResponse>;
+  private tokenizeLocal;
+  /**
+   * Detect PII in text without modifying it
+   *
+   * Returns only the detected entities with their types, positions,
+   * and confidence scores. The original text is not transformed.
+   *
+   * When no API key is set (or `mode: "local"`), detection runs locally
+   * using the built-in regex scanner.
+   *
+   * @param text - Text to analyze for PII
+   * @param config - Optional configuration (entities, score_threshold, policy)
+   * @returns Promise with detected entities
+   */
+  detect(text: string, config?: DetectConfig): Promise<DetectResponse>;
+  private detectLocal;
+  /**
+   * Detokenize text by replacing tokens with original values
+   *
+   * This method performs detokenization CLIENT-SIDE for better performance,
+   * security, and to work offline. No API call is made.
+   *
+   * @param text - Tokenized text
+   * @param mapping - Token mapping from tokenize response
+   * @returns DetokenizeResponse with original text
+   */
+  detokenize(text: string, mapping: Record<string, string>): DetokenizeResponse;
+  /**
+   * Redact (permanently remove) sensitive information from text
+   *
+   * WARNING: Redaction is irreversible - original data cannot be restored!
+   *
+   * When no API key is set (or `mode: "local"`), redaction runs locally
+   * using the built-in regex scanner, replacing PII with `<Entity Name>` placeholders.
+   *
+   * @param text - Text to redact
+   * @param config - Optional configuration (masking_char, entities)
+   * @returns Promise with redacted text and detected entities
+   */
+  redact(text: string, config?: RedactConfig): Promise<RedactResponse>;
+  private redactLocal;
+  /**
+   * Mask (partially hide) sensitive information from text
+   *
+   * @param text - Text to mask
+   * @param config - Optional configuration (chars_to_show, from_end, masking_char, entities)
+   * @returns Promise with masked text and detected entities
+   */
+  mask(text: string, config?: MaskConfig): Promise<MaskResponse>;
+  private maskLocal;
+  /**
+   * Synthesize (replace real data with synthetic fake data)
+   *
+   * When no API key is set (or `mode: "local"`), synthesis runs locally
+   * using format-preserving random generation.
+   *
+   * @param text - Text to synthesize
+   * @param config - Optional configuration (language, entities)
+   * @returns Promise with synthetic text and detected entities
+   */
+  synthesize(text: string, config?: SynthesizeConfig): Promise<SynthesizeResponse>;
+  private synthesizeLocal;
+  /**
+   * Hash (replace with deterministic hash values)
+   *
+   * @param text - Text to hash
+   * @param config - Optional configuration (hash_type, hash_prefix, hash_length, entities)
+   * @returns Promise with hashed text and detected entities
+   */
+  hash(text: string, config?: HashConfig): Promise<HashResponse>;
+  private hashLocal;
+  /**
+   * Encrypt (reversibly protect) sensitive data in text using AES encryption
+   *
+   * @param text - Text to encrypt
+   * @param config - Optional configuration (encryption_key, entities)
+   * @returns Promise with encrypted text and detected entities
+   */
+  encrypt(text: string, config?: EncryptConfig): Promise<EncryptResponse>;
+  private encryptLocal;
+  /**
+   * Tokenize multiple texts in a single request
+   * @param texts - Array of texts to tokenize (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  tokenizeBatch(texts: string[], config?: TokenizeConfig): Promise<BatchResponse>;
+  /**
+   * Detect PII in multiple texts in a single request
+   * @param texts - Array of texts to analyze (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  detectBatch(texts: string[], config?: DetectConfig): Promise<BatchResponse>;
+  /**
+   * Redact PII from multiple texts in a single request
+   * @param texts - Array of texts to redact (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  redactBatch(texts: string[], config?: RedactConfig): Promise<BatchResponse>;
+  /**
+   * Mask PII in multiple texts in a single request
+   * @param texts - Array of texts to mask (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  maskBatch(texts: string[], config?: MaskConfig): Promise<BatchResponse>;
+  /**
+   * Synthesize multiple texts in a single request
+   * @param texts - Array of texts to synthesize (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  synthesizeBatch(texts: string[], config?: SynthesizeConfig): Promise<BatchResponse>;
+  /**
+   * Hash PII in multiple texts in a single request
+   * @param texts - Array of texts to hash (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  hashBatch(texts: string[], config?: HashConfig): Promise<BatchResponse>;
+  /**
+   * Encrypt PII in multiple texts in a single request
+   * @param texts - Array of texts to encrypt (max 100)
+   * @param config - Optional configuration
+   * @returns Promise with batch results
+   */
+  encryptBatch(texts: string[], config?: EncryptConfig): Promise<BatchResponse>;
+} //#endregion
+//#region src/errors.d.ts
+
+//# sourceMappingURL=client.d.ts.map
+/**
+ * Base error class for Blindfold SDK
+ */
+declare class BlindfoldError extends Error {
+  constructor(message: string);
+}
+/**
+ * Error thrown when authentication fails
+ */
+declare class AuthenticationError extends BlindfoldError {
+  constructor(message?: string);
+}
+/**
+ * Error thrown when API request fails
+ */
+declare class APIError extends BlindfoldError {
+  statusCode: number;
+  responseBody?: unknown;
+  constructor(message: string, statusCode: number, responseBody?: unknown);
+}
+/**
+ * Error thrown when network request fails
+ */
+declare class NetworkError extends BlindfoldError {
+  constructor(message?: string);
+}
+
+//#endregion
+//# sourceMappingURL=errors.d.ts.map
+
+export { APIError, APIErrorResponse, AuthenticationError, BatchResponse, Blindfold, BlindfoldConfig, BlindfoldError, DetectConfig, DetectResponse, DetectedEntity, DetokenizeResponse, EntityType, NetworkError, PIIMatch, PIIScanner, TokenizeConfig, TokenizeResponse };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"sourcesContent":null,"mappings":"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"}