@blindfold/sdk 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,450 @@
+import { EntityType, PIIMatch, PIIScanner } from "./index-Dfv8zV_d.js";
+
+//#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.ts.map

package/dist/index.d.ts.map

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