raffel 0.1.2

package/dist/ui/usd/validator/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/usd/validator/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAe,mBAAmB,EAAsB,MAAM,kBAAkB,CAAA;AA8B5F;;;;;GAKG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+aN,CAAA;AAqDV;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,CAqChE;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,UAAU,CAE7C"}

package/dist/ui/usd/validator/semantic.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Semantic validation for USD documents
+ *
+ * Checks for:
+ * - Reference resolution ($ref)
+ * - Circular references
+ * - Cross-protocol consistency
+ * - Missing required fields in protocol-specific sections
+ */
+import type { USDDocument, USDValidationResult } from '../spec/types.js';
+/**
+ * Validate semantic correctness of a USD document
+ */
+export declare function validateSemantic(doc: USDDocument): USDValidationResult;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/ui/usd/validator/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/usd/validator/semantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EAEX,mBAAmB,EAWpB,MAAM,kBAAkB,CAAA;AAUzB;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,WAAW,GAAG,mBAAmB,CA4CtE"}

package/dist/ui/utils/id/alphabets.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ID Alphabets
+ *
+ * Pre-defined character sets for ID generation.
+ * Each alphabet offers different trade-offs between
+ * density (characters per bit) and usability.
+ */
+/**
+ * URL-safe alphabet (64 chars).
+ * Entropy: 6 bits per character
+ * 21 chars = 126 bits of entropy
+ */
+export declare const URL_SAFE = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+/**
+ * URL-safe alphabet without special chars (62 chars).
+ * Alphanumeric only: a-z, A-Z, 0-9
+ * Entropy: ~5.95 bits per character
+ * 22 chars = ~131 bits of entropy
+ */
+export declare const ALPHANUMERIC = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * Lowercase alphanumeric (36 chars).
+ * Entropy: ~5.17 bits per character
+ * 25 chars = ~129 bits of entropy
+ */
+export declare const ALPHANUMERIC_LOWER = "0123456789abcdefghijklmnopqrstuvwxyz";
+/**
+ * Hexadecimal lowercase (16 chars).
+ * Entropy: 4 bits per character
+ * 32 chars = 128 bits of entropy
+ */
+export declare const HEX_LOWER = "0123456789abcdef";
+/**
+ * Hexadecimal uppercase (16 chars).
+ */
+export declare const HEX_UPPER = "0123456789ABCDEF";
+/**
+ * Base58 Bitcoin alphabet (58 chars).
+ * Excludes 0, O, I, l to avoid confusion.
+ * Entropy: ~5.86 bits per character
+ */
+export declare const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+ * Numeric only (10 chars).
+ * Entropy: ~3.32 bits per character
+ * 39 chars = ~129 bits of entropy
+ */
+export declare const NUMERIC = "0123456789";
+export declare const alphabets: {
+    readonly URL_SAFE: "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+    readonly ALPHANUMERIC: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    readonly ALPHANUMERIC_LOWER: "0123456789abcdefghijklmnopqrstuvwxyz";
+    readonly HEX_LOWER: "0123456789abcdef";
+    readonly HEX_UPPER: "0123456789ABCDEF";
+    readonly BASE58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    readonly NUMERIC: "0123456789";
+};
+export type AlphabetName = keyof typeof alphabets;
+/**
+ * Get alphabet by name or return custom alphabet string.
+ */
+export declare function getAlphabet(nameOrCustom: AlphabetName | string): string;
+/**
+ * Validate an alphabet string.
+ * Returns null if valid, error message if invalid.
+ */
+export declare function validateAlphabet(alphabet: string): string | null;
+//# sourceMappingURL=alphabets.d.ts.map

package/dist/ui/utils/id/alphabets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphabets.d.ts","sourceRoot":"","sources":["../../../../src/utils/id/alphabets.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,eAAO,MAAM,QAAQ,qEAAqE,CAAA;AAE1F;;;;;GAKG;AACH,eAAO,MAAM,YAAY,mEAAmE,CAAA;AAE5F;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,yCAAyC,CAAA;AAExE;;;;GAIG;AACH,eAAO,MAAM,SAAS,qBAAqB,CAAA;AAE3C;;GAEG;AACH,eAAO,MAAM,SAAS,qBAAqB,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,MAAM,+DAA+D,CAAA;AAElF;;;;GAIG;AACH,eAAO,MAAM,OAAO,eAAe,CAAA;AAEnC,eAAO,MAAM,SAAS;;;;;;;;CAQZ,CAAA;AAEV,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,SAAS,CAAA;AAEjD;;GAEG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,GAAG,MAAM,CAKvE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBhE"}

package/dist/ui/utils/id/entropy.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Entropy Pool and Random Generation
+ *
+ * Provides cryptographically secure random generation with:
+ * - Pre-allocated entropy pool for performance
+ * - Rejection sampling for zero modulo bias
+ * - Efficient batch generation
+ */
+/**
+ * Initialize or resize the entropy pool.
+ * Uses a pre-allocated buffer to reduce GC pressure and improve performance.
+ */
+export declare function initPool(size?: number): void;
+/**
+ * Get cryptographically secure random bytes from the pool.
+ * Automatically refills the pool when exhausted.
+ */
+export declare function getRandomBytes(count: number): Uint8Array;
+/**
+ * Fill a pre-allocated buffer with random bytes.
+ * More efficient than getRandomBytes when you already have a buffer.
+ */
+export declare function fillRandomBytes(buffer: Uint8Array): Uint8Array;
+/**
+ * Generate multiple unbiased random indices efficiently.
+ * Pre-calculates rejection threshold and batches random byte generation.
+ *
+ * Uses rejection sampling to eliminate modulo bias for non-power-of-2
+ * alphabet sizes.
+ */
+export declare function randomIndicesUnbiased(alphabetSize: number, count: number): Uint16Array;
+/**
+ * Generate a string from an alphabet using unbiased random selection.
+ * This is the core function for generating IDs.
+ */
+export declare function randomString(alphabet: string, length: number): string;
+/**
+ * Calculate the entropy bits for a given alphabet size and ID length.
+ */
+export declare function calculateEntropyBits(alphabetSize: number, length: number): number;
+/**
+ * Reset the entropy pool (useful for testing).
+ */
+export declare function resetPool(): void;
+//# sourceMappingURL=entropy.d.ts.map

package/dist/ui/utils/id/entropy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.ts","sourceRoot":"","sources":["../../../../src/utils/id/entropy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,GAAE,MAA0B,GAAG,IAAI,CAK/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAmBxD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAsB9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CA6DtF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUrE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAGhC"}

package/dist/ui/utils/id/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ID Generation Utilities
+ *
+ * Zero-dependency ID generation with:
+ * - Cryptographically secure randomness
+ * - True uniform distribution (zero modulo bias)
+ * - Multiple alphabet support
+ * - High performance via entropy pooling
+ */
+export { sid, customAlphabet, customAlphabetByName, sidWithOptions, sidEntropyBits, urlAlphabet, } from './sid.js';
+export type { SidOptions } from './sid.js';
+export { URL_SAFE, ALPHANUMERIC, ALPHANUMERIC_LOWER, HEX_LOWER, HEX_UPPER, BASE58, NUMERIC, alphabets, getAlphabet, validateAlphabet, } from './alphabets.js';
+export type { AlphabetName } from './alphabets.js';
+export { randomString, calculateEntropyBits, getRandomBytes, resetPool, } from './entropy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/utils/id/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/id/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,GAAG,EACH,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,WAAW,GACZ,MAAM,UAAU,CAAA;AAEjB,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,MAAM,EACN,OAAO,EACP,SAAS,EACT,WAAW,EACX,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,cAAc,EACd,SAAS,GACV,MAAM,cAAc,CAAA"}

package/dist/ui/utils/id/sid.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SID - Short Unique ID Generator
+ *
+ * A replacement for nanoid with:
+ * - Zero external dependencies
+ * - True uniform distribution via rejection sampling
+ * - Pre-allocated entropy pool for performance
+ * - Multiple alphabet support
+ *
+ * Default: 21 characters using URL-safe alphabet (126 bits of entropy).
+ */
+export interface SidOptions {
+    alphabet?: string;
+    size?: number;
+}
+/**
+ * Generate a short unique ID.
+ * Default: 21 characters using URL-safe alphabet (126 bits of entropy).
+ *
+ * Uses rejection sampling for true uniform distribution (zero modulo bias).
+ *
+ * @example
+ * ```typescript
+ * import { sid } from 'raffel'
+ *
+ * const id = sid()        // 'V1StGXR8_Z5jdHi6B-myT'
+ * const short = sid(10)   // 'IRFa-VaY2b'
+ * ```
+ */
+export declare function sid(size?: number): string;
+/**
+ * Create a custom sid generator with specified alphabet.
+ * Returns a function that generates IDs with that alphabet.
+ *
+ * @example
+ * ```typescript
+ * import { customAlphabet } from 'raffel'
+ *
+ * const numericId = customAlphabet('0123456789', 12)
+ * const id = numericId() // '839146257301'
+ * ```
+ */
+export declare function customAlphabet(alphabet: string, defaultSize?: number): (size?: number) => string;
+/**
+ * Create a custom sid generator with alphabet name.
+ * Supports: URL_SAFE, ALPHANUMERIC, BASE58, HEX_LOWER, etc.
+ *
+ * @example
+ * ```typescript
+ * import { customAlphabetByName } from 'raffel'
+ *
+ * const hexId = customAlphabetByName('HEX_LOWER', 32)
+ * const id = hexId() // 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4'
+ * ```
+ */
+export declare function customAlphabetByName(name: string, defaultSize?: number): (size?: number) => string;
+/**
+ * Generate a sid with options object.
+ *
+ * @example
+ * ```typescript
+ * import { sidWithOptions } from 'raffel'
+ *
+ * const id = sidWithOptions({ size: 16 })
+ * const hex = sidWithOptions({ alphabet: 'HEX_LOWER', size: 32 })
+ * ```
+ */
+export declare function sidWithOptions(options?: SidOptions): string;
+/**
+ * Calculate entropy bits for a sid configuration.
+ *
+ * @example
+ * ```typescript
+ * import { sidEntropyBits } from 'raffel'
+ *
+ * const bits = sidEntropyBits()  // 126 (default: 21 chars * 6 bits)
+ * const hexBits = sidEntropyBits('HEX_LOWER', 32)  // 128
+ * ```
+ */
+export declare function sidEntropyBits(alphabet?: string, size?: number): number;
+/**
+ * URL-safe alphabet constant.
+ */
+export declare const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+export default sid;
+//# sourceMappingURL=sid.d.ts.map

package/dist/ui/utils/id/sid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sid.d.ts","sourceRoot":"","sources":["../../../../src/utils/id/sid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,GAAG,CAAC,IAAI,GAAE,MAAqB,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,WAAW,GAAE,MAAqB,GACjC,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAS3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,MAAqB,GACjC,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAG3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,UAAe,GAAG,MAAM,CAU/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,GAAE,MAAiB,EAC3B,IAAI,GAAE,MAAqB,GAC1B,MAAM,CAGR;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,qEAAW,CAAA;AAEnC,eAAe,GAAG,CAAA"}

package/dist/ui/validation/adapters/ajv.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Ajv (JSON Schema) Validator Adapter
+ *
+ * User must install ajv as a peer dependency.
+ *
+ * Usage:
+ * ```typescript
+ * import Ajv from 'ajv'
+ * import { createAjvAdapter, registerValidator } from 'raffel'
+ *
+ * const ajv = new Ajv({ allErrors: true })
+ * registerValidator(createAjvAdapter(ajv))
+ * ```
+ */
+import type { ValidatorAdapter, ValidationErrorDetails } from '../types.js';
+interface AjvError {
+    instancePath: string;
+    message?: string;
+    keyword: string;
+    params: Record<string, unknown>;
+    schemaPath: string;
+}
+/**
+ * Convert Ajv errors to validation error details
+ */
+declare function ajvErrorToDetails(errors: AjvError[] | null | undefined): ValidationErrorDetails[];
+/**
+ * Create an Ajv (JSON Schema) validator adapter
+ *
+ * @param ajv - An Ajv instance (new Ajv({ allErrors: true }))
+ *
+ * @example
+ * ```typescript
+ * import Ajv from 'ajv'
+ * import addFormats from 'ajv-formats'
+ * import { createAjvAdapter, registerValidator } from 'raffel'
+ *
+ * const ajv = new Ajv({ allErrors: true })
+ * addFormats(ajv) // Optional: adds format validation (email, uri, etc.)
+ *
+ * registerValidator(createAjvAdapter(ajv))
+ *
+ * // Define schema (standard JSON Schema)
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string', minLength: 1 },
+ *     email: { type: 'string', format: 'email' },
+ *   },
+ *   required: ['name', 'email'],
+ * }
+ * ```
+ */
+export declare function createAjvAdapter(ajv: unknown): ValidatorAdapter;
+/**
+ * Re-export error converter for users who need it
+ */
+export { ajvErrorToDetails };
+//# sourceMappingURL=ajv.d.ts.map

package/dist/ui/validation/adapters/ajv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajv.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/ajv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAgB7F,UAAU,QAAQ;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,UAAU,EAAE,MAAM,CAAA;CACnB;AAkCD;;GAEG;AACH,iBAAS,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,sBAAsB,EAAE,CAU1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CA8D/D;AAED;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/ui/validation/adapters/fastest.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Fastest-Validator Adapter
+ *
+ * User must install fastest-validator as a peer dependency.
+ *
+ * Usage:
+ * ```typescript
+ * import Validator from 'fastest-validator'
+ * import { createFastestValidatorAdapter, registerValidator } from 'raffel'
+ *
+ * // Register the adapter
+ * registerValidator(createFastestValidatorAdapter(new Validator()))
+ * ```
+ */
+import type { ValidatorAdapter, ValidationErrorDetails } from '../types.js';
+/**
+ * Fastest-validator instance interface (minimal required)
+ */
+interface FastestValidatorInstance {
+    compile: (schema: Record<string, unknown>) => (data: unknown) => true | ValidationError[];
+}
+interface ValidationError {
+    type: string;
+    field: string;
+    message: string;
+    actual?: unknown;
+    expected?: unknown;
+}
+/**
+ * Convert fastest-validator errors to ValidationErrorDetails
+ */
+declare function fvErrorToDetails(errors: ValidationError[]): ValidationErrorDetails[];
+/**
+ * Create a fastest-validator adapter
+ *
+ * @param validator - A fastest-validator instance (new Validator())
+ *
+ * @example
+ * ```typescript
+ * import Validator from 'fastest-validator'
+ * import { createFastestValidatorAdapter, registerValidator } from 'raffel'
+ *
+ * const v = new Validator()
+ * registerValidator(createFastestValidatorAdapter(v))
+ * ```
+ */
+export declare function createFastestValidatorAdapter(validator: FastestValidatorInstance): ValidatorAdapter;
+/**
+ * Re-export error converter for users who need it
+ */
+export { fvErrorToDetails };
+//# sourceMappingURL=fastest.d.ts.map

package/dist/ui/validation/adapters/fastest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastest.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/fastest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAE7F;;GAEG;AACH,UAAU,wBAAwB;IAChC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,eAAe,EAAE,CAAA;CAC1F;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAmBD;;GAEG;AACH,iBAAS,gBAAgB,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,sBAAsB,EAAE,CAM7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,wBAAwB,GAClC,gBAAgB,CAgFlB;AAgHD;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/ui/validation/adapters/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Validator Adapters
+ *
+ * Factory functions for creating validator adapters.
+ * Users import their preferred validator library and pass it to the factory.
+ *
+ * Supported validators (top 4 + fastest-validator):
+ * - Zod - TypeScript-first schema validation
+ * - Yup - Object schema validation
+ * - Joi - Powerful schema validation
+ * - Ajv - JSON Schema validator (fastest JSON Schema validator)
+ * - fastest-validator - Blazing fast validator
+ */
+export { createZodAdapter, zodErrorToDetails } from './zod.js';
+export { createYupAdapter, yupErrorToDetails } from './yup.js';
+export { createJoiAdapter, joiErrorToDetails } from './joi.js';
+export { createAjvAdapter, ajvErrorToDetails } from './ajv.js';
+export { createFastestValidatorAdapter, fvErrorToDetails } from './fastest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/validation/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA"}

package/dist/ui/validation/adapters/joi.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Joi Validator Adapter
+ *
+ * User must install joi as a peer dependency.
+ *
+ * Usage:
+ * ```typescript
+ * import Joi from 'joi'
+ * import { createJoiAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createJoiAdapter(Joi))
+ * ```
+ */
+import type { ValidatorAdapter, ValidationErrorDetails } from '../types.js';
+interface JoiValidationError {
+    details: Array<{
+        path: Array<string | number>;
+        message: string;
+        type: string;
+    }>;
+    message: string;
+}
+/**
+ * Convert Joi errors to validation error details
+ */
+declare function joiErrorToDetails(error: JoiValidationError): ValidationErrorDetails[];
+/**
+ * Create a Joi validator adapter
+ *
+ * @param _joi - The Joi module (import Joi from 'joi')
+ *
+ * @example
+ * ```typescript
+ * import Joi from 'joi'
+ * import { createJoiAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createJoiAdapter(Joi))
+ *
+ * // Define schema
+ * const schema = Joi.object({
+ *   name: Joi.string().required().min(1),
+ *   email: Joi.string().email().required(),
+ * })
+ * ```
+ */
+export declare function createJoiAdapter(_joi: unknown): ValidatorAdapter;
+/**
+ * Re-export error converter for users who need it
+ */
+export { joiErrorToDetails };
+//# sourceMappingURL=joi.d.ts.map

package/dist/ui/validation/adapters/joi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"joi.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/joi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAa7F,UAAU,kBAAkB;IAC1B,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;QAC5B,OAAO,EAAE,MAAM,CAAA;QACf,IAAI,EAAE,MAAM,CAAA;KACb,CAAC,CAAA;IACF,OAAO,EAAE,MAAM,CAAA;CAChB;AAgBD;;GAEG;AACH,iBAAS,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,GAAG,sBAAsB,EAAE,CAM9E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CA4ChE;AA8MD;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/ui/validation/adapters/yup.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Yup Validator Adapter
+ *
+ * User must install yup as a peer dependency.
+ *
+ * Usage:
+ * ```typescript
+ * import * as yup from 'yup'
+ * import { createYupAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createYupAdapter(yup))
+ * ```
+ */
+import type { ValidatorAdapter, ValidationErrorDetails } from '../types.js';
+interface YupValidationError {
+    inner: Array<{
+        path: string;
+        message: string;
+        type: string;
+    }>;
+    path?: string;
+    message: string;
+    type?: string;
+}
+/**
+ * Convert Yup errors to validation error details
+ */
+declare function yupErrorToDetails(error: YupValidationError): ValidationErrorDetails[];
+/**
+ * Create a Yup validator adapter
+ *
+ * @param _yup - The yup module (import * as yup from 'yup')
+ *
+ * @example
+ * ```typescript
+ * import * as yup from 'yup'
+ * import { createYupAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createYupAdapter(yup))
+ *
+ * // Define schema
+ * const schema = yup.object({
+ *   name: yup.string().required().min(1),
+ *   email: yup.string().email().required(),
+ * })
+ * ```
+ */
+export declare function createYupAdapter(_yup: unknown): ValidatorAdapter;
+/**
+ * Re-export error converter for users who need it
+ */
+export { yupErrorToDetails };
+//# sourceMappingURL=yup.d.ts.map

package/dist/ui/validation/adapters/yup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yup.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/yup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAY7F,UAAU,kBAAkB;IAC1B,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAeD;;GAEG;AACH,iBAAS,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,GAAG,sBAAsB,EAAE,CAgB9E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CA2ChE;AAoMD;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/ui/validation/adapters/zod.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Zod Validator Adapter
+ *
+ * User must install zod and zod-to-json-schema as peer dependencies.
+ *
+ * Usage:
+ * ```typescript
+ * import { z } from 'zod'
+ * import { createZodAdapter, registerValidator } from 'raffel'
+ *
+ * // Register the adapter
+ * registerValidator(createZodAdapter(z))
+ * ```
+ */
+import type { ValidatorAdapter, ValidationErrorDetails } from '../types.js';
+interface ZodError {
+    issues: Array<{
+        path: PropertyKey[];
+        message: string;
+        code: string;
+    }>;
+}
+/**
+ * Convert Zod error to validation error details
+ */
+declare function zodErrorToDetails(error: ZodError): ValidationErrorDetails[];
+/**
+ * Create a Zod validator adapter
+ *
+ * @param zod - The zod module (import { z } from 'zod')
+ * @param zodToJsonSchema - Optional zod-to-json-schema function for OpenAPI support
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ * import { zodToJsonSchema } from 'zod-to-json-schema'
+ * import { createZodAdapter, registerValidator } from 'raffel'
+ *
+ * // Basic usage
+ * registerValidator(createZodAdapter(z))
+ *
+ * // With JSON Schema support
+ * registerValidator(createZodAdapter(z, zodToJsonSchema))
+ * ```
+ */
+export declare function createZodAdapter(_zod: unknown, // We don't actually need the module, just validate schemas
+zodToJsonSchema?: (schema: unknown) => Record<string, unknown>): ValidatorAdapter;
+/**
+ * Re-export error converter for users who need it
+ */
+export { zodErrorToDetails };
+//# sourceMappingURL=zod.d.ts.map

package/dist/ui/validation/adapters/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../../src/validation/adapters/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAW7F,UAAU,QAAQ;IAChB,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,WAAW,EAAE,CAAA;QACnB,OAAO,EAAE,MAAM,CAAA;QACf,IAAI,EAAE,MAAM,CAAA;KACb,CAAC,CAAA;CACH;AAoBD;;GAEG;AACH,iBAAS,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,sBAAsB,EAAE,CAOpE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EAAE,2DAA2D;AAC1E,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7D,gBAAgB,CAqDlB;AAED;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/ui/validation/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Validation Module
+ *
+ * Multi-validator support for Raffel handlers.
+ * Users choose their validator: Zod, fastest-validator, or custom.
+ *
+ * @example
+ * ```typescript
+ * // Using Zod
+ * import { z } from 'zod'
+ * import { createZodAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createZodAdapter(z))
+ *
+ * // Using fastest-validator
+ * import Validator from 'fastest-validator'
+ * import { createFastestValidatorAdapter, registerValidator } from 'raffel'
+ *
+ * registerValidator(createFastestValidatorAdapter(new Validator()))
+ * ```
+ */
+export type { ValidatorType, ValidatorAdapter, ValidationResult, ValidationErrorDetails, ValidationConfig, HandlerSchema, } from './types.js';
+export { DEFAULT_VALIDATION_CONFIG } from './types.js';
+export { configureValidation, getValidationConfig, registerValidator, getValidator, hasValidator, listValidators, validate, createValidationInterceptor, createSchemaValidationInterceptor, createSchemaRegistry, type SchemaRegistry, resetValidation, } from './schema.js';
+export { createZodAdapter, zodErrorToDetails, createYupAdapter, yupErrorToDetails, createJoiAdapter, joiErrorToDetails, createAjvAdapter, ajvErrorToDetails, createFastestValidatorAdapter, fvErrorToDetails, } from './adapters/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAGtD,OAAO,EAEL,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,cAAc,EAEd,QAAQ,EAER,2BAA2B,EAC3B,iCAAiC,EAEjC,oBAAoB,EACpB,KAAK,cAAc,EAEnB,eAAe,GAChB,MAAM,aAAa,CAAA;AAIpB,OAAO,EAEL,gBAAgB,EAChB,iBAAiB,EAEjB,gBAAgB,EAChB,iBAAiB,EAEjB,gBAAgB,EAChB,iBAAiB,EAEjB,gBAAgB,EAChB,iBAAiB,EAEjB,6BAA6B,EAC7B,gBAAgB,GACjB,MAAM,qBAAqB,CAAA"}