@docknetwork/wallet-sdk-core 1.5.14 → 1.7.0

package/lib/qr-handlers/builtin/oid4vc-handler.d.ts

@@ -0,0 +1,137 @@
+import { QRCodeContext, QRCodeHandler, QRCodeHandlerResult } from '../types';
+/**
+ * Configuration options for OID4VC handler
+ */
+export interface OID4VCHandlerConfig {
+    /**
+     * URI prefixes to match (default: ['openid-credential-offer://'])
+     */
+    uriPrefixes?: string[];
+    /**
+     * Priority for this handler (default: 5)
+     */
+    priority?: number;
+    /**
+     * Callback to handle credential import
+     * This is where app-specific logic (navigation, UI, etc.) should be implemented
+     *
+     * @param uri - The OID4VC URI to process
+     * @param context - The full QR code context
+     * @returns Result of the import operation
+     */
+    onImportCredential: (uri: string, context: QRCodeContext) => Promise<OID4VCImportResult>;
+}
+/**
+ * Result from importing an OID4VC credential
+ */
+export interface OID4VCImportResult {
+    /**
+     * Whether the import was successful
+     */
+    success: boolean;
+    /**
+     * Credential data if import succeeded
+     */
+    credential?: any;
+    /**
+     * Error if import failed
+     */
+    error?: Error;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Built-in handler for OID4VC (OpenID for Verifiable Credentials) URIs
+ *
+ * This is a generic handler that can be configured with app-specific callbacks
+ * for importing credentials. The handler itself only handles protocol detection
+ * and delegates the actual import logic to the configured callback.
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * import { OID4VCHandler } from '@docknetwork/wallet-sdk-core/src/qr-handlers/builtin';
+ * import { getCredentialProvider } from '@docknetwork/wallet-sdk-react-native';
+ *
+ * const handler = new OID4VCHandler({
+ *   onImportCredential: async (uri, context) => {
+ *     try {
+ *       // Use SDK to import credential
+ *       await getCredentialProvider().importCredentialFromURI({
+ *         uri,
+ *         didProvider: getDIDProvider(),
+ *         getAuthCode: async (authUrl) => {
+ *           // App-specific auth handling
+ *           return await showAuthWebView(authUrl);
+ *         },
+ *       });
+ *
+ *       return { success: true };
+ *     } catch (error) {
+ *       return {
+ *         success: false,
+ *         error: error instanceof Error ? error : new Error(String(error)),
+ *       };
+ *     }
+ *   },
+ * });
+ *
+ * processor.registerHandler(handler);
+ * ```
+ *
+ * ## Handler Priority
+ *
+ * Default priority: 5 (very high)
+ * This ensures OID4VC URIs are checked before other credential handlers.
+ *
+ * @category Built-in Handlers
+ */
+export declare class OID4VCHandler implements QRCodeHandler {
+    id: string;
+    priority: number;
+    private uriPrefixes;
+    private onImportCredential;
+    constructor(config: OID4VCHandlerConfig);
+    /**
+     * Check if this is an OID4VC URI
+     *
+     * Matches URIs that start with any of the configured prefixes.
+     * By default, matches: openid-credential-offer://
+     *
+     * @param context - The QR code context
+     * @returns True if this handler can process the URI
+     */
+    canHandle(context: QRCodeContext): boolean;
+    /**
+     * Process the OID4VC credential offer URI
+     *
+     * Delegates to the configured onImportCredential callback for actual processing.
+     * This allows apps to implement their own navigation, UI, and error handling.
+     *
+     * @param context - The QR code context
+     * @returns Result of the processing
+     */
+    handle(context: QRCodeContext): Promise<QRCodeHandlerResult>;
+}
+/**
+ * Create an OID4VC handler with custom configuration
+ *
+ * This is a convenience factory function for creating an OID4VC handler.
+ *
+ * @param config - Handler configuration
+ * @returns Configured OID4VC handler
+ *
+ * @example
+ * ```typescript
+ * const handler = createOID4VCHandler({
+ *   onImportCredential: async (uri) => {
+ *     // Your import logic
+ *     return { success: true };
+ *   },
+ * });
+ * ```
+ */
+export declare function createOID4VCHandler(config: OID4VCHandlerConfig): OID4VCHandler;
+//# sourceMappingURL=oid4vc-handler.d.ts.map

package/lib/qr-handlers/builtin/oid4vc-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oid4vc-handler.d.ts","sourceRoot":"","sources":["../../../src/qr-handlers/builtin/oid4vc-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,aAAa,EACb,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAElB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,kBAAkB,EAAE,CAClB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,aAAa,KACnB,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,GAAG,CAAC;IAEjB;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBAAa,aAAc,YAAW,aAAa;IACjD,EAAE,SAAY;IACd,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,kBAAkB,CAGO;gBAErB,MAAM,EAAE,mBAAmB;IAUvC;;;;;;;;OAQG;IACH,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAI1C;;;;;;;;OAQG;IACG,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA0BnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,mBAAmB,GAC1B,aAAa,CAEf"}

package/lib/qr-handlers/builtin/oid4vc-handler.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OID4VCHandler = void 0;
+exports.createOID4VCHandler = createOID4VCHandler;
+/**
+ * Built-in handler for OID4VC (OpenID for Verifiable Credentials) URIs
+ *
+ * This is a generic handler that can be configured with app-specific callbacks
+ * for importing credentials. The handler itself only handles protocol detection
+ * and delegates the actual import logic to the configured callback.
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * import { OID4VCHandler } from '@docknetwork/wallet-sdk-core/src/qr-handlers/builtin';
+ * import { getCredentialProvider } from '@docknetwork/wallet-sdk-react-native';
+ *
+ * const handler = new OID4VCHandler({
+ *   onImportCredential: async (uri, context) => {
+ *     try {
+ *       // Use SDK to import credential
+ *       await getCredentialProvider().importCredentialFromURI({
+ *         uri,
+ *         didProvider: getDIDProvider(),
+ *         getAuthCode: async (authUrl) => {
+ *           // App-specific auth handling
+ *           return await showAuthWebView(authUrl);
+ *         },
+ *       });
+ *
+ *       return { success: true };
+ *     } catch (error) {
+ *       return {
+ *         success: false,
+ *         error: error instanceof Error ? error : new Error(String(error)),
+ *       };
+ *     }
+ *   },
+ * });
+ *
+ * processor.registerHandler(handler);
+ * ```
+ *
+ * ## Handler Priority
+ *
+ * Default priority: 5 (very high)
+ * This ensures OID4VC URIs are checked before other credential handlers.
+ *
+ * @category Built-in Handlers
+ */
+class OID4VCHandler {
+    id = 'oid4vc';
+    priority;
+    uriPrefixes;
+    onImportCredential;
+    constructor(config) {
+        if (!config.onImportCredential) {
+            throw new Error('onImportCredential callback is required');
+        }
+        this.priority = config.priority ?? 5;
+        this.uriPrefixes = config.uriPrefixes ?? ['openid-credential-offer://'];
+        this.onImportCredential = config.onImportCredential;
+    }
+    /**
+     * Check if this is an OID4VC URI
+     *
+     * Matches URIs that start with any of the configured prefixes.
+     * By default, matches: openid-credential-offer://
+     *
+     * @param context - The QR code context
+     * @returns True if this handler can process the URI
+     */
+    canHandle(context) {
+        return this.uriPrefixes.some(prefix => context.data.startsWith(prefix));
+    }
+    /**
+     * Process the OID4VC credential offer URI
+     *
+     * Delegates to the configured onImportCredential callback for actual processing.
+     * This allows apps to implement their own navigation, UI, and error handling.
+     *
+     * @param context - The QR code context
+     * @returns Result of the processing
+     */
+    async handle(context) {
+        try {
+            const result = await this.onImportCredential(context.data, context);
+            return {
+                success: result.success,
+                data: result.credential,
+                error: result.error,
+                metadata: {
+                    type: 'oid4vc',
+                    uri: context.data,
+                    ...result.metadata,
+                },
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            return {
+                success: false,
+                error: err,
+                metadata: {
+                    type: 'oid4vc',
+                    uri: context.data,
+                },
+            };
+        }
+    }
+}
+exports.OID4VCHandler = OID4VCHandler;
+/**
+ * Create an OID4VC handler with custom configuration
+ *
+ * This is a convenience factory function for creating an OID4VC handler.
+ *
+ * @param config - Handler configuration
+ * @returns Configured OID4VC handler
+ *
+ * @example
+ * ```typescript
+ * const handler = createOID4VCHandler({
+ *   onImportCredential: async (uri) => {
+ *     // Your import logic
+ *     return { success: true };
+ *   },
+ * });
+ * ```
+ */
+function createOID4VCHandler(config) {
+    return new OID4VCHandler(config);
+}
+//# sourceMappingURL=oid4vc-handler.js.map

package/lib/qr-handlers/builtin/oid4vc-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oid4vc-handler.js","sourceRoot":"","sources":["../../../src/qr-handlers/builtin/oid4vc-handler.ts"],"names":[],"mappings":";;;AAiMA,kDAIC;AA1ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAa,aAAa;IACxB,EAAE,GAAG,QAAQ,CAAC;IACd,QAAQ,CAAS;IAET,WAAW,CAAW;IACtB,kBAAkB,CAGO;IAEjC,YAAY,MAA2B;QACrC,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,4BAA4B,CAAC,CAAC;QACxE,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC;IACtD,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,OAAsB;QAC9B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,CAAC,OAAsB;QACjC,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YAEpE,OAAO;gBACL,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,IAAI,EAAE,MAAM,CAAC,UAAU;gBACvB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,GAAG,EAAE,OAAO,CAAC,IAAI;oBACjB,GAAG,MAAM,CAAC,QAAQ;iBACnB;aACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,GAAG,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACtE,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,GAAG;gBACV,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,GAAG,EAAE,OAAO,CAAC,IAAI;iBAClB;aACF,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AApED,sCAoEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,mBAAmB,CACjC,MAA2B;IAE3B,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC"}

package/lib/qr-handlers/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * QR Code Handler System
+ *
+ * This module provides a generic, extensible system for processing QR codes
+ * in decentralized identity wallet applications.
+ *
+ * ## Overview
+ *
+ * The QR handler system is built around these core concepts:
+ *
+ * - **QRCodeContext**: Contains parsed QR data (raw string, JSON, URLs)
+ * - **QRCodeHandler**: Interface for implementing specific QR code processors
+ * - **QRCodeProcessor**: Manages handler registration and execution
+ * - **ProcessOptions**: Configuration for how QR codes are processed
+ *
+ * ## Basic Usage
+ *
+ * ```typescript
+ * import { createQRCodeProcessor } from '@docknetwork/wallet-sdk-core';
+ *
+ * // Create processor
+ * const processor = createQRCodeProcessor();
+ *
+ * // Register handlers
+ * processor.registerHandler({
+ *   id: 'my-handler',
+ *   priority: 10,
+ *   canHandle: (context) => context.data.startsWith('myprotocol://'),
+ *   handle: async (context) => {
+ *     // Process the QR code
+ *     return { success: true };
+ *   }
+ * });
+ *
+ * // Process QR code
+ * const result = await processor.process(scannedData);
+ * ```
+ *
+ * ## Custom Handlers
+ *
+ * Handlers can be implemented as classes or objects:
+ *
+ * ```typescript
+ * class MyCustomHandler implements QRCodeHandler {
+ *   id = 'my-custom-handler';
+ *   priority = 20;
+ *
+ *   canHandle(context: QRCodeContext): boolean {
+ *     return context.jsonData?.type === 'my-type';
+ *   }
+ *
+ *   async handle(context: QRCodeContext): Promise<QRCodeHandlerResult> {
+ *     // Your processing logic
+ *     return { success: true, data: processedData };
+ *   }
+ * }
+ *
+ * processor.registerHandler(new MyCustomHandler());
+ * ```
+ *
+ * ## Built-in Handlers
+ *
+ * The SDK provides built-in handlers for common protocols:
+ * - OID4VC (OpenID for Verifiable Credentials)
+ * - OID4VP (OpenID for Verifiable Presentations)
+ * - DIDComm (Decentralized Identity Communication)
+ *
+ * These handlers are available in separate modules and can be imported
+ * and registered as needed.
+ *
+ * @module qr-handlers
+ */
+export * from './types';
+export * from './processor';
+export * from './builtin';
+//# sourceMappingURL=index.d.ts.map

package/lib/qr-handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/qr-handlers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/lib/qr-handlers/index.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * QR Code Handler System
+ *
+ * This module provides a generic, extensible system for processing QR codes
+ * in decentralized identity wallet applications.
+ *
+ * ## Overview
+ *
+ * The QR handler system is built around these core concepts:
+ *
+ * - **QRCodeContext**: Contains parsed QR data (raw string, JSON, URLs)
+ * - **QRCodeHandler**: Interface for implementing specific QR code processors
+ * - **QRCodeProcessor**: Manages handler registration and execution
+ * - **ProcessOptions**: Configuration for how QR codes are processed
+ *
+ * ## Basic Usage
+ *
+ * ```typescript
+ * import { createQRCodeProcessor } from '@docknetwork/wallet-sdk-core';
+ *
+ * // Create processor
+ * const processor = createQRCodeProcessor();
+ *
+ * // Register handlers
+ * processor.registerHandler({
+ *   id: 'my-handler',
+ *   priority: 10,
+ *   canHandle: (context) => context.data.startsWith('myprotocol://'),
+ *   handle: async (context) => {
+ *     // Process the QR code
+ *     return { success: true };
+ *   }
+ * });
+ *
+ * // Process QR code
+ * const result = await processor.process(scannedData);
+ * ```
+ *
+ * ## Custom Handlers
+ *
+ * Handlers can be implemented as classes or objects:
+ *
+ * ```typescript
+ * class MyCustomHandler implements QRCodeHandler {
+ *   id = 'my-custom-handler';
+ *   priority = 20;
+ *
+ *   canHandle(context: QRCodeContext): boolean {
+ *     return context.jsonData?.type === 'my-type';
+ *   }
+ *
+ *   async handle(context: QRCodeContext): Promise<QRCodeHandlerResult> {
+ *     // Your processing logic
+ *     return { success: true, data: processedData };
+ *   }
+ * }
+ *
+ * processor.registerHandler(new MyCustomHandler());
+ * ```
+ *
+ * ## Built-in Handlers
+ *
+ * The SDK provides built-in handlers for common protocols:
+ * - OID4VC (OpenID for Verifiable Credentials)
+ * - OID4VP (OpenID for Verifiable Presentations)
+ * - DIDComm (Decentralized Identity Communication)
+ *
+ * These handlers are available in separate modules and can be imported
+ * and registered as needed.
+ *
+ * @module qr-handlers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./processor"), exports);
+__exportStar(require("./builtin"), exports);
+//# sourceMappingURL=index.js.map

package/lib/qr-handlers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/qr-handlers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;;;;;;;;;;;;;;;;AAEH,0CAAwB;AACxB,8CAA4B;AAC5B,4CAA0B"}

package/lib/qr-handlers/processor.d.ts

@@ -0,0 +1,110 @@
+import { QRCodeHandler, QRCodeHandlerResult, QRCodeProcessor, ProcessOptions } from './types';
+/**
+ * Default implementation of QRCodeProcessor
+ *
+ * This processor manages a registry of QR code handlers and executes them
+ * in priority order to process scanned QR codes. It provides a flexible,
+ * extensible system for handling various types of QR codes in a wallet application.
+ *
+ * @example
+ * ```typescript
+ * const processor = new DefaultQRCodeProcessor();
+ *
+ * // Register handlers
+ * processor.registerHandler(new OID4VCHandler());
+ * processor.registerHandler(new CredentialHandler());
+ *
+ * // Process QR code
+ * const result = await processor.process(scannedData);
+ * if (result.success) {
+ *   console.log('QR code processed:', result.data);
+ * } else {
+ *   console.error('Failed to process QR code:', result.error);
+ * }
+ * ```
+ */
+export declare class DefaultQRCodeProcessor implements QRCodeProcessor {
+    private handlers;
+    /**
+     * Register a new QR code handler
+     *
+     * @param handler - The handler to register
+     * @throws Error if a handler with the same ID is already registered
+     */
+    registerHandler(handler: QRCodeHandler): void;
+    /**
+     * Unregister a QR code handler by its ID
+     *
+     * @param id - The ID of the handler to unregister
+     * @returns True if the handler was found and removed, false otherwise
+     */
+    unregisterHandler(id: string): boolean;
+    /**
+     * Get all registered handlers sorted by priority
+     *
+     * @returns Array of registered handlers sorted by priority (lowest first)
+     */
+    getHandlers(): QRCodeHandler[];
+    /**
+     * Get a specific handler by its ID
+     *
+     * @param id - The ID of the handler to retrieve
+     * @returns The handler if found, undefined otherwise
+     */
+    getHandler(id: string): QRCodeHandler | undefined;
+    /**
+     * Clear all registered handlers
+     */
+    clearHandlers(): void;
+    /**
+     * Process QR code data through registered handlers
+     *
+     * This method:
+     * 1. Prepares the context from raw QR data
+     * 2. Executes handlers in priority order
+     * 3. Returns the first successful result (or continues if stopOnFirstSuccess is false)
+     * 4. Returns an error result if no handler can process the data
+     *
+     * @param data - Raw QR code data string
+     * @param options - Processing options
+     * @returns Result of the processing
+     */
+    process(data: string, options?: ProcessOptions): Promise<QRCodeHandlerResult>;
+    /**
+     * Default context preparation function
+     *
+     * This method attempts to parse the raw QR data as JSON or URL.
+     * Override this by providing a custom prepareContext function in ProcessOptions.
+     *
+     * @param data - Raw QR code data string
+     * @returns Prepared context object
+     */
+    private defaultPrepareContext;
+    /**
+     * Execute a promise with a timeout
+     *
+     * @param promise - Promise to execute
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Result of the promise
+     * @throws Error if the promise times out
+     */
+    private withTimeout;
+}
+/**
+ * Create a new QR code processor instance
+ *
+ * This is a convenience factory function for creating a processor.
+ *
+ * @param handlers - Optional array of handlers to register immediately
+ * @returns New processor instance with handlers registered
+ *
+ * @example
+ * ```typescript
+ * const processor = createQRCodeProcessor([
+ *   new OID4VCHandler(),
+ *   new CredentialHandler(),
+ * ]);
+ * ```
+ */
+export declare function createQRCodeProcessor(handlers?: QRCodeHandler[]): QRCodeProcessor;
+//# sourceMappingURL=processor.d.ts.map

package/lib/qr-handlers/processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../src/qr-handlers/processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC5D,OAAO,CAAC,QAAQ,CAAyC;IAEzD;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAU7C;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAItC;;;;OAIG;IACH,WAAW,IAAI,aAAa,EAAE;IAM9B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIjD;;OAEG;IACH,aAAa,IAAI,IAAI;IAIrB;;;;;;;;;;;;OAYG;IACG,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC;IAsH/B;;;;;;;;OAQG;YACW,qBAAqB;IA0BnC;;;;;;;OAOG;YACW,WAAW;CAc1B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,CAAC,EAAE,aAAa,EAAE,GACzB,eAAe,CAUjB"}