@gesslar/toolkit 0.5.0 → 0.7.0

package/src/types/lib/Glog.d.ts

@@ -0,0 +1,113 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+declare const _default: typeof Glog;
+export default _default;
+declare class Glog {
+    static logLevel: number;
+    static logPrefix: string;
+    static colors: any;
+    static stackTrace: boolean;
+    static name: string;
+    static setLogPrefix(prefix: any): typeof Glog;
+    static setLogLevel(level: any): typeof Glog;
+    static withName(name: any): typeof Glog;
+    static withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): typeof Glog;
+    static withStackTrace(enabled?: boolean): typeof Glog;
+    static create(options?: {}): Glog;
+    static execute(...args: any[]): void;
+    /**
+     * Static version of colorize for global usage
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     */
+    static colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Static success method
+     *
+     * @param {string} message - Success message to log
+     * @param {...unknown} args - Additional arguments to log
+     */
+    static success(message: string, ...args: unknown[]): void;
+    /**
+     * Set a color alias for convenient usage
+     *
+     * @param {string} alias - Alias name
+     * @param {string} colorCode - Color code (e.g., "{F196}" or "{<B}")
+     * @returns {Glog} The Glog class for chaining.
+     */
+    static setAlias(alias: string, colorCode: string): Glog;
+    constructor(options?: {});
+    setOptions(options: any): this;
+    withName(name: any): this;
+    withLogLevel(level: any): this;
+    withPrefix(prefix: any): this;
+    withColors(colors?: {
+        debug: string[];
+        info: string;
+        warn: string;
+        error: string;
+        reset: string;
+    }): this;
+    withStackTrace(enabled?: boolean): this;
+    get name(): string;
+    get debugLevel(): number;
+    get options(): {
+        name: string;
+        debugLevel: number;
+        prefix: string;
+        colors: any;
+        stackTrace: boolean;
+    };
+    extractFileFunction(): string;
+    newDebug(tag: any): any;
+    /**
+     * Log a debug message with specified verbosity level.
+     * Level 0 means debug OFF - use levels 1-4 for actual debug output.
+     * Debug messages only show when logLevel > 0.
+     *
+     * @param {string} message - Debug message to log
+     * @param {number} level - Debug verbosity level (1-4, default: 1)
+     * @param {...unknown} arg - Additional arguments to log
+     * @throws {Error} If level < 1 (level 0 = debug OFF)
+     */
+    debug(message: string, level?: number, ...arg: unknown[]): void;
+    info(message: any, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    execute(...args: any[]): void;
+    /**
+     * Log a colorized message using template literals
+     *
+     * @param {Array<string>} strings - Template strings
+     * @param {...unknown} values - Template values
+     * @example logger.colorize`{success}Operation completed{/} in {bold}${time}ms{/}`
+     */
+    colorize(strings: Array<string>, ...values: unknown[]): void;
+    /**
+     * Log a success message with green color
+     *
+     * @param {string} message - Success message
+     * @param {...unknown} args - Additional arguments
+     */
+    success(message: string, ...args: unknown[]): void;
+    /**
+     * Get access to the colours template function for instance usage
+     *
+     * @returns {import('@gesslar/colours')} The colours template function from \@gesslar/colours
+     */
+    get colours(): typeof import("@gesslar/colours");
+    #private;
+}
+//# sourceMappingURL=Glog.d.ts.map

package/src/types/lib/Glog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Glog.d.ts","sourceRoot":"","sources":["../../lib/Glog.js"],"names":[],"mappings":";;;;;;;;;AA6CA;IAEE,wBAAmB;IACnB,yBAAqB;IACrB,mBAAoB;IACpB,2BAAyB;IACzB,oBAAgB;IA2ChB,8CAIC;IAED,4CAIC;IAED,wCAIC;IAED;;;;;;oBAIC;IAED,sDAIC;IAID,kCAEC;IAwJD,qCAoBC;IAuBD;;;;;OAKG;IACH,yBAHW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAOpB;IAYD;;;;;OAKG;IACH,wBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAMhB;IAhTD,0BAeC;IAID,+BAQC;IAwCD,0BAIC;IAED,+BAIC;IAED,8BAIC;IAED;;;;;;aAIC;IAED,wCAIC;IAID,mBAEC;IAED,yBAEC;IAED;;;;;;MAQC;IAqBD,8BAGC;IAED,wBAQC;IA8BD;;;;;;;;;OASG;IACH,eALW,MAAM,UACN,MAAM,UACH,OAAO,EAAA,QAapB;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;IA0BD,8BAEC;IAID;;;;;;OAMG;IACH,kBAJW,KAAK,CAAC,MAAM,CAAC,aACV,OAAO,EAAA,QAQpB;IAeD;;;;;OAKG;IACH,iBAHW,MAAM,WACH,OAAO,EAAA,QAIpB;IAyBD;;;;OAIG;IACH,iDAEC;;CACF"}

package/src/types/lib/Logger.d.ts

@@ -0,0 +1,46 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but, should be
+ *          logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery, starting to get more
+ *         detailed
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+export default class Logger {
+    constructor(options: any);
+    vscodeError: any;
+    vscodeWarn: any;
+    vscodeInfo: any;
+    get name(): any;
+    get debugLevel(): number;
+    get options(): {
+        name: any;
+        debugLevel: number;
+    };
+    setOptions(options: any): void;
+    lastStackLine(error?: Error, stepsRemoved?: number): any;
+    extractFileFunction(level?: number): any;
+    newDebug(tag: any): any;
+    debug(message: any, level?: number, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    info(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    #private;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/src/types/lib/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../lib/Logger.js"],"names":[],"mappings":";;;;;;;AA4CA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAYC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,yDAIC;IAED,yCAsCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF"}

package/src/types/lib/Sass.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Custom error class for toolkit errors.
+ * Provides error chaining, trace management, and formatted error reporting.
+ */
+export default class Sass extends Error {
+    /**
+     * Creates an Sass from an existing Error object with additional
+     * trace message.
+     *
+     * @param {Error} error - The original error object
+     * @param {string} message - Additional trace message to add
+     * @returns {Sass} New Sass instance with trace from the original error
+     * @throws {Sass} If the first parameter is not an Error instance
+     */
+    static from(error: Error, message: string): Sass;
+    /**
+     * Factory method to create or enhance Sass instances.
+     * If error parameter is provided, enhances existing Sass or wraps
+     * other errors. Otherwise creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {Error|Sass|Tantrum} [error] - Optional existing error to wrap or enhance
+     * @returns {Sass} New or enhanced Sass instance
+     */
+    static "new"(message: string, error?: Error | Sass | Tantrum): Sass;
+    /**
+     * Creates a new Sass instance.
+     *
+     * @param {string} message - The error message
+     * @param {...unknown} [arg] - Additional arguments passed to parent Error constructor
+     */
+    constructor(message: string, ...arg?: unknown[]);
+    /**
+     * Adds a message to the beginning of the trace array.
+     *
+     * @param {string} message - The trace message to add
+     */
+    set trace(message: string);
+    /**
+     * Gets the error trace array.
+     *
+     * @returns {Array<string>} Array of trace messages
+     */
+    get trace(): Array<string>;
+    /**
+     * Adds a trace message and returns this instance for chaining.
+     *
+     * @param {string} message - The trace message to add
+     * @returns {this} This Sass instance for method chaining
+     */
+    addTrace(message: string): this;
+    /**
+     * Reports the error to the terminal with formatted output.
+     * Optionally includes detailed stack trace information.
+     *
+     * @param {boolean} [nerdMode] - Whether to include detailed stack trace
+     */
+    report(nerdMode?: boolean): void;
+    #private;
+}
+import Tantrum from "./Tantrum.js";
+//# sourceMappingURL=Sass.d.ts.map

package/src/types/lib/Sass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IA2GE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IAhJD;;;;;OAKG;IACH,qBAHW,MAAM,WACH,OAAO,EAAA,EAMpB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,kBAFW,OAAO,QAqBjB;;CA2EF;oBA1JmB,cAAc"}

package/src/types/lib/Schemer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Schemer provides utilities for compiling and validating JSON schemas using AJV.
+ *
+ * Usage:
+ *   - Use Schemer.fromFile(file, options) to create a validator from a file.
+ *   - Use Schemer.from(schemaData, options) to create a validator from a schema object.
+ *   - Use Schemer.getValidator(schema, options) to get a raw AJV validator function.
+ *   - Use Schemer.reportValidationErrors(errors) to format AJV validation errors.
+ */
+export default class Schemer {
+    static fromFile(file: any, options?: {}): Promise<(data: unknown) => boolean>;
+    static from(schemaData?: {}, options?: {}): Promise<(data: unknown) => boolean>;
+    /**
+     * Creates a validator function from a schema object
+     *
+     * @param {object} schema - The schema to compile
+     * @param {object} [options] - AJV options
+     * @returns {(data: unknown) => boolean} The AJV validator function, which may have additional properties (e.g., `.errors`)
+     */
+    static getValidator(schema: object, options?: object): (data: unknown) => boolean;
+    static reportValidationErrors(errors: any): any;
+}
+//# sourceMappingURL=Schemer.d.ts.map

package/src/types/lib/Schemer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schemer.d.ts","sourceRoot":"","sources":["../../lib/Schemer.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IACE,yDAqBoB,OAAO,KAAK,OAAO,EAdtC;IAED,2DAYoB,OAAO,KAAK,OAAO,EAPtC;IAED;;;;;;OAMG;IACH,4BAJW,MAAM,YACN,MAAM,GACJ,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAMtC;IAED,gDA0CC;CACF"}

package/src/types/lib/Tantrum.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Custom aggregate error class that extends AggregateError.
+ * Automatically wraps plain errors in Sass instances for consistent reporting.
+ */
+export default class Tantrum extends AggregateError {
+    /**
+     * Factory method to create a Tantrum instance.
+     *
+     * @param {string} message - The aggregate error message
+     * @param {Array<Error|Sass>} errors - Array of errors to aggregate
+     * @returns {Tantrum} New Tantrum instance
+     */
+    static "new"(message: string, errors?: Array<Error | Sass>): Tantrum;
+    /**
+     * Creates a new Tantrum instance.
+     *
+     * @param {string} message - The aggregate error message
+     * @param {Array<Error|Sass>} errors - Array of errors to aggregate
+     */
+    constructor(message: string, errors?: Array<Error | Sass>);
+    /**
+     * Adds a trace message and returns this instance for chaining.
+     *
+     * @param {string} message - The trace message to add
+     * @param {Error|Sass} [_error] - Optional error (currently unused, reserved for future use)
+     * @returns {this} This Tantrum instance for method chaining
+     */
+    addTrace(message: string, _error?: Error | Sass): this;
+    /**
+     * Adds a message to the beginning of the trace array.
+     *
+     * @param {string} message - The trace message to add
+     */
+    set trace(message: string);
+    /**
+     * Gets the error trace array.
+     *
+     * @returns {Array<string>} Array of trace messages
+     */
+    get trace(): Array<string>;
+    /**
+     * Reports all aggregated errors to the terminal with formatted output.
+     *
+     * @param {boolean} [nerdMode] - Whether to include detailed stack traces
+     */
+    report(nerdMode?: boolean): void;
+    #private;
+}
+import Sass from "./Sass.js";
+//# sourceMappingURL=Tantrum.d.ts.map

package/src/types/lib/Tantrum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../lib/Tantrum.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAgFE;;;;;;OAMG;IACH,sBAJW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,GACf,OAAO,CAOnB;IAzFD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,KAAK,CAAC,KAAK,GAAC,IAAI,CAAC,EAgB3B;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,WACN,KAAK,GAAC,IAAI,GACR,IAAI,CAShB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;OAIG;IACH,kBAFW,OAAO,QAgBjB;;CAeF;iBApGgB,WAAW"}

package/src/types/lib/Term.d.ts

@@ -0,0 +1,103 @@
+export default class Term {
+    /**
+     * Log an informational message.
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static log(...arg?: unknown[]): void;
+    /**
+     * Log an informational message.
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static info(...arg?: unknown[]): void;
+    /**
+     * Log a warning message.
+     *
+     * @param {...unknown} [arg] - Warning text / object.
+     */
+    static warn(...arg?: unknown[]): void;
+    /**
+     * Log an error message (plus optional details).
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static error(...arg?: unknown[]): void;
+    /**
+     * Log a debug message (no-op unless console.debug provided/visible by env).
+     *
+     * @param {...unknown} [arg] - Values to log.
+     */
+    static debug(...arg?: unknown[]): void;
+    /**
+     * Emit a status line to the terminal.
+     *
+     * Accepts either a plain string or an array of message segments (see
+     * `terminalMessage()` for formatting options). If `silent` is true, output
+     * is suppressed.
+     *
+     * This is a convenient shortcut for logging status updates, with optional
+     * formatting and easy suppression.
+     *
+     * @param {string | Array<string | [string, string]>} args - Message or segments.
+     * @param {object} [options] - Behaviour flags.
+     * @param {boolean} options.silent - When true, suppress output.
+     * @returns {void}
+     */
+    static status(args: string | Array<string | [string, string]>, { silent }?: {
+        silent: boolean;
+    }): void;
+    /**
+     * Constructs a formatted status line.
+     *
+     * Input forms:
+     *  - string: printed as-is
+     *  - array: each element is either:
+     *    - a plain string (emitted unchanged), or
+     *    - a tuple: [level, text] where `level` maps to an ansiColors alias
+     *        (e.g. success, info, warn, error, modified).
+     *    - a tuple: [level, text, [openBracket,closeBracket]] where `level` maps to an ansiColors alias
+     *        (e.g. success, info, warn, error, modified). These are rendered as
+     *        colourised bracketed segments: [TEXT].
+     *
+     * The function performs a shallow validation: tuple elements must both be
+     * strings; otherwise a TypeError is thrown. Nested arrays beyond depth 1 are
+     * not supported.
+     *
+     * Recursion: array input is normalised into a single string then re-dispatched
+     * through `status` to leverage the string branch (keeps logic DRY).
+     *
+     * @param {string | Array<string | [string, string] | [string, string, string]>} argList - Message spec.
+     * @returns {void}
+     */
+    static terminalMessage(argList: string | Array<string | [string, string] | [string, string, string]>): void;
+    /**
+     * Construct a single coloured bracketed segment from a tuple specifying
+     * the style level and the text. The first element ("level") maps to an
+     * `ansiColors` alias (e.g. success, info, warn, error, modified) and is
+     * used both for the inner text colour and to locate its matching
+     * "-bracket" alias for the surrounding square brackets. The second
+     * element is the raw text to display.
+     *
+     * Input validation: every element of `parts` must be a string; otherwise
+     * an `Sass` error is thrown. (Additional elements beyond the first two are
+     * ignored – the method destructures only the first pair.)
+     *
+     * Example:
+     *  terminalBracket(["success", "COMPILED"]) → "[COMPILED]" with coloured
+     *  brackets + inner text (assuming colour support is available in the
+     *  terminal).
+     *
+     * This method does not append trailing spaces; callers are responsible for
+     * joining multiple segments with appropriate separators.
+     *
+     * @param {Array<string>} parts - Tuple: [level, text]. Additional entries ignored.
+     * @returns {string} Colourised bracketed segment (e.g. "[TEXT]").
+     * @throws {Sass} If any element of `parts` is not a string.
+     */
+    static terminalBracket([level, text, brackets]: Array<string>): string;
+    static resetTerminal(): Promise<void>;
+    static clearLines(num: any): Promise<void>;
+    static directWrite(output: any): Promise<any>;
+}
+//# sourceMappingURL=Term.d.ts.map

package/src/types/lib/Term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../lib/Term.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,oBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,eAEjD;QAAyB,MAAM,EAAvB,OAAO;KACf,GAAU,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAHW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAClE,IAAI,CA4BhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gDAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CASlB;IAED,sCAGC;IAED,2CAEC;IAED,8CAIC;CACF"}

package/src/types/lib/Terms.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Terms represents an interface definition - what an action promises to provide or accept.
+ * It's just the specification, not the negotiation. Contract handles the negotiation.
+ */
+export default class Terms {
+    /**
+     * Parses terms data, handling file references
+     *
+     * @param {string|object} termsData - Terms data or reference
+     * @param {DirectoryObject?} directoryObject - Directory context for file resolution
+     * @returns {object} Parsed terms data
+     */
+    static parse(termsData: string | object, directoryObject: DirectoryObject | null): object;
+    constructor(definition: any);
+    /**
+     * Get the terms definition
+     *
+     * @returns {object} The terms definition
+     */
+    get definition(): object;
+    #private;
+}
+import DirectoryObject from "./DirectoryObject.js";
+//# sourceMappingURL=Terms.d.ts.map

package/src/types/lib/Terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Terms.d.ts","sourceRoot":"","sources":["../../lib/Terms.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAOE;;;;;;OAMG;IACH,wBAJW,MAAM,GAAC,MAAM,mBACb,eAAe,OAAC,GACd,MAAM,CAmClB;IA5CD,6BAEC;IA4CD;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;;CAEF;4BArE2B,sBAAsB"}

package/src/types/lib/TypeSpec.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Type specification class for parsing and validating complex type definitions.
+ * Supports union types, array types, and validation options.
+ */
+export default class TypeSpec {
+    /**
+     * Creates a new TypeSpec instance.
+     *
+     * @param {string} string - The type specification string (e.g., "string|number", "object[]")
+     * @param {object} options - Additional parsing options
+     */
+    constructor(string: string, options: object);
+    specs: any[];
+    length: number;
+    stringRepresentation: string;
+    /**
+     * Returns a string representation of the type specification.
+     *
+     * @returns {string} The type specification as a string (e.g., "string|number[]")
+     */
+    toString(): string;
+    /**
+     * Returns a JSON representation of the TypeSpec.
+     *
+     * @returns {object} Object containing specs, length, and string representation
+     */
+    toJSON(): object;
+    /**
+     * Executes a provided function once for each type specification.
+     *
+     * @param {function(unknown): void} callback - Function to execute for each spec
+     */
+    forEach(callback: (arg0: unknown) => void): void;
+    /**
+     * Tests whether all type specifications pass the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {boolean} True if all specs pass the test
+     */
+    every(callback: (arg0: unknown) => boolean): boolean;
+    /**
+     * Tests whether at least one type specification passes the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {boolean} True if at least one spec passes the test
+     */
+    some(callback: (arg0: unknown) => boolean): boolean;
+    /**
+     * Creates a new array with all type specifications that pass the provided test function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {Array<unknown>} New array with filtered specs
+     */
+    filter(callback: (arg0: unknown) => boolean): Array<unknown>;
+    /**
+     * Creates a new array populated with the results of calling the provided function on every spec.
+     *
+     * @param {function(unknown): unknown} callback - Function to call on each spec
+     * @returns {Array<unknown>} New array with mapped values
+     */
+    map(callback: (arg0: unknown) => unknown): Array<unknown>;
+    /**
+     * Executes a reducer function on each spec, resulting in a single output value.
+     *
+     * @param {function(unknown, unknown): unknown} callback - Function to execute on each spec
+     * @param {unknown} initialValue - Initial value for the accumulator
+     * @returns {unknown} The final accumulated value
+     */
+    reduce(callback: (arg0: unknown, arg1: unknown) => unknown, initialValue: unknown): unknown;
+    /**
+     * Returns the first type specification that satisfies the provided testing function.
+     *
+     * @param {function(unknown): boolean} callback - Function to test each spec
+     * @returns {object|undefined} The first spec that matches, or undefined
+     */
+    find(callback: (arg0: unknown) => boolean): object | undefined;
+    /**
+     * Tests whether a value matches any of the type specifications.
+     * Handles array types, union types, and empty value validation.
+     *
+     * @param {unknown} value - The value to test against the type specifications
+     * @param {object} options - Validation options
+     * @param {boolean} options.allowEmpty - Whether empty values are allowed
+     * @returns {boolean} True if the value matches any type specification
+     */
+    matches(value: unknown, options: {
+        allowEmpty: boolean;
+    }): boolean;
+    match(value: any, options: any): false | unknown[];
+    #private;
+}
+//# sourceMappingURL=TypeSpec.d.ts.map

package/src/types/lib/TypeSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,MAAM,EAUhB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,MAAM,CASlB;IAED;;;;OAIG;IACH,kBAFW,CAAS,IAAO,EAAP,OAAO,KAAG,IAAI,QAIjC;IAED;;;;;OAKG;IACH,gBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;OAKG;IACH,cAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,iBAJW,CAAS,IAAO,EAAP,OAAO,EAAE,IAAO,EAAP,OAAO,KAAG,OAAO,gBACnC,OAAO,GACL,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;OAQG;IACH,eALW,OAAO,WAEf;QAAyB,UAAU,EAA3B,OAAO;KACf,GAAU,OAAO,CAInB;IAED,mDAkDC;;CAiCF"}