gavio 0.1.0

package/dist/esm/interceptors/cache/backends/memory.js

@@ -0,0 +1,50 @@
+/** In-memory cache backend (F-CACHE-03) — default zero-dependency dev backend. */
+/** LRU-bounded, optionally TTL'd in-process cache. Not shared across processes. */
+class MemoryBackend {
+    maxSize;
+    // Map preserves insertion order, which we use for LRU eviction.
+    store = new Map();
+    constructor(maxSize = 1000) {
+        this.maxSize = maxSize;
+    }
+    async get(key) {
+        const entry = this.store.get(key);
+        if (entry === undefined)
+            return null;
+        if (entry.expiresAt !== null && now() > entry.expiresAt) {
+            this.store.delete(key);
+            return null;
+        }
+        // Move to end (most-recently-used).
+        this.store.delete(key);
+        this.store.set(key, entry);
+        return entry.value;
+    }
+    async set(key, value, ttlSeconds) {
+        const expiresAt = ttlSeconds ? now() + ttlSeconds * 1000 : null;
+        this.store.delete(key);
+        this.store.set(key, { value, expiresAt });
+        while (this.store.size > this.maxSize) {
+            const oldest = this.store.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.store.delete(oldest);
+        }
+    }
+    async delete(key) {
+        this.store.delete(key);
+    }
+    async clear() {
+        this.store.clear();
+    }
+    get size() {
+        return this.store.size;
+    }
+}
+function now() {
+    return Date.now();
+}
+/** Factory: build an in-memory cache backend. */
+export function memoryCacheBackend(options = {}) {
+    return new MemoryBackend(options.maxSize ?? 1000);
+}

package/dist/esm/interceptors/cache/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Caching substrate. The SemanticCache interceptor ships in v0.2.0; v0.1.0
+ * exposes the CacheBackend interface and the in-memory backend only.
+ */
+export type { CacheBackend } from './backend.js';
+export { memoryCacheBackend } from './backends/memory.js';
+export type { MemoryCacheBackendOptions } from './backends/memory.js';

package/dist/esm/interceptors/cache/index.js

@@ -0,0 +1,5 @@
+/**
+ * Caching substrate. The SemanticCache interceptor ships in v0.2.0; v0.1.0
+ * exposes the CacheBackend interface and the in-memory backend only.
+ */
+export { memoryCacheBackend } from './backends/memory.js';

package/dist/esm/interceptors/chain.d.ts

@@ -0,0 +1,17 @@
+/** InterceptorChain — runs the pre/post pipeline around the provider call. */
+import type { InterceptorContext } from '../context.js';
+import type { GavioRequest } from '../request.js';
+import type { GavioResponse } from '../response.js';
+import type { Executor, Interceptor } from './base.js';
+/**
+ * Ordered list of interceptors wrapping an executor.
+ *
+ * `before` hooks fire in order; the executor runs; `after` hooks fire in
+ * reverse order (onion model). If any stage throws, every interceptor's
+ * `onError` is invoked before the error propagates.
+ */
+export declare class InterceptorChain {
+    private readonly interceptors;
+    constructor(interceptors: Interceptor[]);
+    execute(request: GavioRequest, ctx: InterceptorContext, executor: Executor): Promise<GavioResponse>;
+}

package/dist/esm/interceptors/chain.js

@@ -0,0 +1,53 @@
+/** InterceptorChain — runs the pre/post pipeline around the provider call. */
+const dryRunSafe = (i) => i.dryRunSafe !== false;
+/**
+ * Ordered list of interceptors wrapping an executor.
+ *
+ * `before` hooks fire in order; the executor runs; `after` hooks fire in
+ * reverse order (onion model). If any stage throws, every interceptor's
+ * `onError` is invoked before the error propagates.
+ */
+export class InterceptorChain {
+    interceptors;
+    constructor(interceptors) {
+        this.interceptors = [...interceptors];
+    }
+    async execute(request, ctx, executor) {
+        try {
+            let req = request;
+            for (const interceptor of this.interceptors) {
+                if (ctx.dryRun && !dryRunSafe(interceptor))
+                    continue;
+                if (interceptor.before) {
+                    req = await interceptor.before(req, ctx);
+                }
+                ctx.markFired(interceptor.name);
+            }
+            let response = await executor(req);
+            for (let i = this.interceptors.length - 1; i >= 0; i--) {
+                const interceptor = this.interceptors[i];
+                if (ctx.dryRun && !dryRunSafe(interceptor))
+                    continue;
+                if (interceptor.after) {
+                    response = await interceptor.after(response, ctx);
+                }
+            }
+            response.interceptorsFired = [...ctx.interceptorsFired];
+            return response;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            for (const interceptor of this.interceptors) {
+                if (interceptor.onError) {
+                    try {
+                        await interceptor.onError(err, ctx);
+                    }
+                    catch {
+                        // on_error must never break the propagation of the original error.
+                    }
+                }
+            }
+            throw error;
+        }
+    }
+}

package/dist/esm/interceptors/index.d.ts

@@ -0,0 +1,8 @@
+/** Interceptor barrel. */
+export type { Interceptor, Executor, ExecutorPolicy } from './base.js';
+export { isExecutorPolicy } from './base.js';
+export { InterceptorChain } from './chain.js';
+export { piiGuard } from './pii/index.js';
+export { auditInterceptor } from './audit/index.js';
+export { retryInterceptor, timeoutPolicy, fallbackChain } from './reliability/index.js';
+export { memoryCacheBackend } from './cache/index.js';

package/dist/esm/interceptors/index.js

@@ -0,0 +1,7 @@
+/** Interceptor barrel. */
+export { isExecutorPolicy } from './base.js';
+export { InterceptorChain } from './chain.js';
+export { piiGuard } from './pii/index.js';
+export { auditInterceptor } from './audit/index.js';
+export { retryInterceptor, timeoutPolicy, fallbackChain } from './reliability/index.js';
+export { memoryCacheBackend } from './cache/index.js';

package/dist/esm/interceptors/pii/context.d.ts

@@ -0,0 +1,15 @@
+/** ScanContext — per-request state shared across PII scanners. */
+/**
+ * Context threaded through every scanner for one request.
+ *
+ * Tracks a monotonic per-entity-type index so repeated entities get stable,
+ * distinct placeholders (`[EMAIL_1]`, `[EMAIL_2]`).
+ */
+export declare class ScanContext {
+    readonly language: string;
+    readonly locale: string;
+    private counters;
+    constructor(language?: string, locale?: string);
+    /** Return the next 1-based index for an entity type. */
+    nextIndex(entityType: string): number;
+}

package/dist/esm/interceptors/pii/context.js

@@ -0,0 +1,21 @@
+/** ScanContext — per-request state shared across PII scanners. */
+/**
+ * Context threaded through every scanner for one request.
+ *
+ * Tracks a monotonic per-entity-type index so repeated entities get stable,
+ * distinct placeholders (`[EMAIL_1]`, `[EMAIL_2]`).
+ */
+export class ScanContext {
+    language;
+    locale;
+    counters = {};
+    constructor(language = 'en', locale = 'NL') {
+        this.language = language;
+        this.locale = locale;
+    }
+    /** Return the next 1-based index for an entity type. */
+    nextIndex(entityType) {
+        this.counters[entityType] = (this.counters[entityType] ?? 0) + 1;
+        return this.counters[entityType];
+    }
+}

package/dist/esm/interceptors/pii/guard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * PiiGuard — the pre/post interceptor that detects and redacts PII.
+ *
+ * Pipeline rule (privacy): PII is scanned on every request before it reaches
+ * the provider. Detected entities are redacted/masked/tagged or blocked. In
+ * REDACT mode the original values are restored in the response.
+ */
+import { PiiMode, Sensitivity } from '../../types.js';
+import type { Interceptor } from '../base.js';
+import type { PiiMatch } from './match.js';
+import type { PiiScanner } from './scanner.js';
+export interface PiiGuardOptions {
+    scanners?: PiiScanner[];
+    sensitivity?: Sensitivity;
+    mode?: PiiMode;
+    restoreOnResponse?: boolean;
+    logEntityTypes?: boolean;
+    dryRun?: boolean;
+    locale?: string;
+    language?: string;
+}
+/**
+ * Drop lower-priority matches that overlap a kept one.
+ *
+ * Sort by start, then by descending span length (prefer the longer match),
+ * then by confidence. Greedily keep non-overlapping matches.
+ */
+export declare function resolveOverlaps(matches: PiiMatch[]): PiiMatch[];
+/** Factory: build a PiiGuard interceptor. */
+export declare function piiGuard(options?: PiiGuardOptions): Interceptor;

package/dist/esm/interceptors/pii/guard.js

@@ -0,0 +1,157 @@
+/**
+ * PiiGuard — the pre/post interceptor that detects and redacts PII.
+ *
+ * Pipeline rule (privacy): PII is scanned on every request before it reaches
+ * the provider. Detected entities are redacted/masked/tagged or blocked. In
+ * REDACT mode the original values are restored in the response.
+ */
+import { PiiBlockedError } from '../../errors.js';
+import { PiiMode, Sensitivity } from '../../types.js';
+import { ScanContext } from './context.js';
+import { matchLength } from './match.js';
+import { scannerTier } from './scanner.js';
+import { defaultScanners } from './scanners/index.js';
+const STATE_KEY = 'pii_replacements';
+// Confidence floor per sensitivity level — matches below the floor are ignored.
+const CONFIDENCE_FLOOR = {
+    [Sensitivity.STRICT]: 0.0,
+    [Sensitivity.BALANCED]: 0.6,
+    [Sensitivity.PERMISSIVE]: 0.9,
+};
+class PiiGuard {
+    name = 'pii_guard';
+    dryRunSafe = true;
+    scanners;
+    sensitivity;
+    mode;
+    restoreOnResponse;
+    logEntityTypes;
+    ownDryRun;
+    locale;
+    language;
+    constructor(options = {}) {
+        this.scanners = options.scanners ?? defaultScanners();
+        this.sensitivity = options.sensitivity ?? Sensitivity.STRICT;
+        this.mode = options.mode ?? PiiMode.REDACT;
+        this.restoreOnResponse = options.restoreOnResponse ?? true;
+        this.logEntityTypes = options.logEntityTypes ?? true;
+        this.ownDryRun = options.dryRun ?? false;
+        this.locale = options.locale ?? 'NL';
+        this.language = options.language ?? 'en';
+    }
+    async before(request, ctx) {
+        const scanCtx = new ScanContext(this.language, this.locale);
+        const floor = CONFIDENCE_FLOOR[this.sensitivity];
+        const newMessages = [];
+        const allTypes = [];
+        const replacements = ctx.state[STATE_KEY] ?? {};
+        const isDryRun = this.ownDryRun || ctx.dryRun;
+        for (const message of request.messages) {
+            const content = message.content ?? '';
+            const matches = await this.scanText(content, scanCtx, floor);
+            for (const m of matches)
+                allTypes.push(m.entityType);
+            if (matches.length > 0 && this.mode === PiiMode.BLOCK) {
+                const types = matches.map((m) => m.entityType);
+                throw new PiiBlockedError(types);
+            }
+            let redacted = content;
+            if (matches.length > 0 && !isDryRun) {
+                redacted = this.apply(content, matches, replacements);
+            }
+            newMessages.push({ ...message, content: redacted });
+        }
+        if (allTypes.length > 0) {
+            ctx.recordPii(allTypes);
+            if (this.logEntityTypes) {
+                const unique = Array.from(new Set(allTypes)).sort();
+                // eslint-disable-next-line no-console
+                console.info(`[gavio:pii] detected entity types: ${unique.join(', ')}`);
+            }
+        }
+        if (this.restoreOnResponse && Object.keys(replacements).length > 0) {
+            ctx.state[STATE_KEY] = replacements;
+        }
+        if (isDryRun)
+            return request;
+        return request.copyWithMessages(newMessages);
+    }
+    async after(response, ctx) {
+        if (!this.restoreOnResponse || this.mode !== PiiMode.REDACT)
+            return response;
+        const replacements = ctx.state[STATE_KEY];
+        if (!replacements || Object.keys(replacements).length === 0)
+            return response;
+        let content = response.content;
+        for (const [token, original] of Object.entries(replacements)) {
+            content = content.split(token).join(original);
+        }
+        if (content === response.content)
+            return response;
+        return response.copyWithContent(content);
+    }
+    async scanText(text, scanCtx, floor) {
+        const raw = [];
+        const ordered = [...this.scanners].sort((a, b) => scannerTier(a) - scannerTier(b));
+        for (const scanner of ordered) {
+            const found = await scanner.scan(text, scanCtx);
+            for (const match of found) {
+                if (match.confidence >= floor)
+                    raw.push(match);
+            }
+        }
+        return resolveOverlaps(raw);
+    }
+    apply(text, matches, replacements) {
+        // Replace right-to-left so earlier offsets stay valid.
+        const ordered = [...matches].sort((a, b) => b.start - a.start);
+        let out = text;
+        for (const match of ordered) {
+            const token = this.tokenFor(match);
+            if (this.mode === PiiMode.REDACT) {
+                replacements[token] = match.value;
+            }
+            out = out.slice(0, match.start) + token + out.slice(match.end);
+        }
+        return out;
+    }
+    tokenFor(match) {
+        if (this.mode === PiiMode.MASK) {
+            return '*'.repeat(Math.max(matchLength(match), 1));
+        }
+        if (this.mode === PiiMode.TAG) {
+            return `<${match.entityType}>${match.value}</${match.entityType}>`;
+        }
+        // REDACT (default)
+        return match.replacement || `[${match.entityType}]`;
+    }
+}
+/**
+ * Drop lower-priority matches that overlap a kept one.
+ *
+ * Sort by start, then by descending span length (prefer the longer match),
+ * then by confidence. Greedily keep non-overlapping matches.
+ */
+export function resolveOverlaps(matches) {
+    const ordered = [...matches].sort((a, b) => {
+        if (a.start !== b.start)
+            return a.start - b.start;
+        const lenDiff = matchLength(b) - matchLength(a);
+        if (lenDiff !== 0)
+            return lenDiff;
+        return b.confidence - a.confidence;
+    });
+    const kept = [];
+    let occupiedEnd = -1;
+    for (const match of ordered) {
+        if (match.start >= occupiedEnd) {
+            kept.push(match);
+            occupiedEnd = match.end;
+        }
+    }
+    return kept;
+}
+/** Factory: build a PiiGuard interceptor. */
+export function piiGuard(options = {}) {
+    return new PiiGuard(options);
+}

package/dist/esm/interceptors/pii/index.d.ts

@@ -0,0 +1,10 @@
+/** PII guard public surface. */
+export { piiGuard, resolveOverlaps } from './guard.js';
+export type { PiiGuardOptions } from './guard.js';
+export { ScanContext } from './context.js';
+export { ScannerRegistry, scannerTier } from './scanner.js';
+export type { PiiScanner } from './scanner.js';
+export { makeMatch, matchLength } from './match.js';
+export type { PiiMatch } from './match.js';
+export { PiiMode, Sensitivity } from '../../types.js';
+export { bsnScanner, creditCardScanner, emailScanner, ibanScanner, ipAddressScanner, phoneScanner, secretScanner, ssnScanner, defaultScanners, } from './scanners/index.js';

package/dist/esm/interceptors/pii/index.js

@@ -0,0 +1,7 @@
+/** PII guard public surface. */
+export { piiGuard, resolveOverlaps } from './guard.js';
+export { ScanContext } from './context.js';
+export { ScannerRegistry, scannerTier } from './scanner.js';
+export { makeMatch, matchLength } from './match.js';
+export { PiiMode, Sensitivity } from '../../types.js';
+export { bsnScanner, creditCardScanner, emailScanner, ibanScanner, ipAddressScanner, phoneScanner, secretScanner, ssnScanner, defaultScanners, } from './scanners/index.js';

package/dist/esm/interceptors/pii/match.d.ts

@@ -0,0 +1,26 @@
+/** PiiMatch — a single detected PII entity within a span of text. */
+/**
+ * One detected entity.
+ *
+ * `start`/`end` are half-open character offsets into the scanned text.
+ * `replacement` is the placeholder used in REDACT mode; `value` is the
+ * original text (never logged — used only for restore).
+ */
+export interface PiiMatch {
+    entityType: string;
+    start: number;
+    end: number;
+    value: string;
+    confidence: number;
+    /** e.g. '[EMAIL_1]'. */
+    replacement: string;
+}
+export declare function matchLength(m: PiiMatch): number;
+export declare function makeMatch(init: {
+    entityType: string;
+    start: number;
+    end: number;
+    value: string;
+    confidence?: number;
+    replacement: string;
+}): PiiMatch;

package/dist/esm/interceptors/pii/match.js

@@ -0,0 +1,17 @@
+/** PiiMatch — a single detected PII entity within a span of text. */
+export function matchLength(m) {
+    return m.end - m.start;
+}
+export function makeMatch(init) {
+    if (init.start < 0 || init.end < init.start) {
+        throw new Error(`Invalid PiiMatch span: start=${init.start}, end=${init.end}`);
+    }
+    return {
+        entityType: init.entityType,
+        start: init.start,
+        end: init.end,
+        value: init.value,
+        confidence: init.confidence ?? 1.0,
+        replacement: init.replacement,
+    };
+}

package/dist/esm/interceptors/pii/scanner.d.ts

@@ -0,0 +1,32 @@
+/** PiiScanner interface and ScannerRegistry. */
+import type { ScanContext } from './context.js';
+import type { PiiMatch } from './match.js';
+/**
+ * Detects one class of PII entity within text.
+ *
+ * Scanners are tiered: tier 1 = regex, tier 2 = NER/ML, tier 3 = LLM. Lower
+ * tiers run first so cheap deterministic matches are found before expensive
+ * ones. v0.1.0 ships only tier-1 regex scanners.
+ */
+export interface PiiScanner {
+    /** e.g. 'EMAIL', 'IBAN', 'BSN'. */
+    readonly entityType: string;
+    /** default: 1 */
+    readonly tier?: 1 | 2 | 3;
+    scan(text: string, ctx: ScanContext): PiiMatch[] | Promise<PiiMatch[]>;
+    /** default: 1.0 */
+    readonly confidence?: number;
+    supportsLanguage?(lang: string): boolean;
+    supportsLocale?(locale: string): boolean;
+}
+export declare function scannerTier(s: PiiScanner): number;
+/** Registry of scanners, discoverable by entity type at runtime. */
+export declare class ScannerRegistry {
+    private scanners;
+    constructor(scanners?: PiiScanner[]);
+    register(scanner: PiiScanner): this;
+    /** Return scanners sorted by tier (lowest first). */
+    all(): PiiScanner[];
+    byEntityType(entityType: string): PiiScanner[];
+    get size(): number;
+}

package/dist/esm/interceptors/pii/scanner.js

@@ -0,0 +1,26 @@
+/** PiiScanner interface and ScannerRegistry. */
+export function scannerTier(s) {
+    return s.tier ?? 1;
+}
+/** Registry of scanners, discoverable by entity type at runtime. */
+export class ScannerRegistry {
+    scanners = [];
+    constructor(scanners) {
+        for (const s of scanners ?? [])
+            this.register(s);
+    }
+    register(scanner) {
+        this.scanners.push(scanner);
+        return this;
+    }
+    /** Return scanners sorted by tier (lowest first). */
+    all() {
+        return [...this.scanners].sort((a, b) => scannerTier(a) - scannerTier(b));
+    }
+    byEntityType(entityType) {
+        return this.scanners.filter((s) => s.entityType === entityType);
+    }
+    get size() {
+        return this.scanners.length;
+    }
+}

package/dist/esm/interceptors/pii/scanners/bsn.d.ts

@@ -0,0 +1,5 @@
+/** Dutch BSN scanner — regex + 11-proef (eleven-test) checksum. */
+import type { PiiScanner } from '../scanner.js';
+/** 11-proef: sum of digit*weight (9,8,...,2,-1) must be divisible by 11. */
+export declare function validBsn(digits: string): boolean;
+export declare function bsnScanner(): PiiScanner;

package/dist/esm/interceptors/pii/scanners/bsn.js

@@ -0,0 +1,37 @@
+/** Dutch BSN scanner — regex + 11-proef (eleven-test) checksum. */
+import { makeMatch } from '../match.js';
+// BSN is 8 or 9 digits; we validate the 9-digit form with the 11-proef.
+const BSN = /\b\d{9}\b/g;
+/** 11-proef: sum of digit*weight (9,8,...,2,-1) must be divisible by 11. */
+export function validBsn(digits) {
+    if (digits.length !== 9)
+        return false;
+    const weights = [9, 8, 7, 6, 5, 4, 3, 2, -1];
+    let total = 0;
+    for (let i = 0; i < 9; i++) {
+        total += Number(digits[i]) * weights[i];
+    }
+    return total % 11 === 0;
+}
+export function bsnScanner() {
+    return {
+        entityType: 'BSN',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(BSN)) {
+                if (!validBsn(m[0]))
+                    continue;
+                const idx = ctx.nextIndex('BSN');
+                out.push(makeMatch({
+                    entityType: 'BSN',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    replacement: `[BSN_${idx}]`,
+                }));
+            }
+            return out;
+        },
+    };
+}

package/dist/esm/interceptors/pii/scanners/credit-card.d.ts

@@ -0,0 +1,4 @@
+/** Credit card scanner — regex candidate + Luhn checksum validation. */
+import type { PiiScanner } from '../scanner.js';
+export declare function luhnValid(number: string): boolean;
+export declare function creditCardScanner(): PiiScanner;

package/dist/esm/interceptors/pii/scanners/credit-card.js

@@ -0,0 +1,47 @@
+/** Credit card scanner — regex candidate + Luhn checksum validation. */
+import { makeMatch } from '../match.js';
+// 13–19 digits, optionally separated by single spaces or hyphens.
+const CARD = /\b(?:\d[ -]?){12,18}\d\b/g;
+export function luhnValid(number) {
+    const digits = [];
+    for (const c of number) {
+        if (c >= '0' && c <= '9')
+            digits.push(c.charCodeAt(0) - 48);
+    }
+    if (digits.length < 13 || digits.length > 19)
+        return false;
+    let checksum = 0;
+    const parity = digits.length % 2;
+    for (let i = 0; i < digits.length; i++) {
+        let d = digits[i];
+        if (i % 2 === parity) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        checksum += d;
+    }
+    return checksum % 10 === 0;
+}
+export function creditCardScanner() {
+    return {
+        entityType: 'CREDIT_CARD',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(CARD)) {
+                if (!luhnValid(m[0]))
+                    continue;
+                const idx = ctx.nextIndex('CREDIT_CARD');
+                out.push(makeMatch({
+                    entityType: 'CREDIT_CARD',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    replacement: `[CREDIT_CARD_${idx}]`,
+                }));
+            }
+            return out;
+        },
+    };
+}

package/dist/esm/interceptors/pii/scanners/email.d.ts

@@ -0,0 +1,3 @@
+/** Email address scanner (RFC 5322 pragmatic subset). */
+import type { PiiScanner } from '../scanner.js';
+export declare function emailScanner(): PiiScanner;

package/dist/esm/interceptors/pii/scanners/email.js

@@ -0,0 +1,23 @@
+/** Email address scanner (RFC 5322 pragmatic subset). */
+import { makeMatch } from '../match.js';
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+export function emailScanner() {
+    return {
+        entityType: 'EMAIL',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(EMAIL)) {
+                const idx = ctx.nextIndex('EMAIL');
+                out.push(makeMatch({
+                    entityType: 'EMAIL',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    replacement: `[EMAIL_${idx}]`,
+                }));
+            }
+            return out;
+        },
+    };
+}

package/dist/esm/interceptors/pii/scanners/iban.d.ts

@@ -0,0 +1,5 @@
+/** IBAN scanner — regex candidate + ISO 13616 mod-97 checksum validation. */
+import type { PiiScanner } from '../scanner.js';
+/** ISO 13616 mod-97: rearrange, convert letters to numbers, check %97 == 1. */
+export declare function validIban(candidate: string): boolean;
+export declare function ibanScanner(): PiiScanner;