@orkestrel/validator 0.0.1

package/dist/arrays.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Narrow an unknown value to an array.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an array.
+ * @example
+ * ```ts
+ * isArray([1, 2])
+ * ```
+ */
+export declare function isArray<T = unknown>(value: readonly T[]): boolean;
+export declare function isArray<T = unknown>(value: unknown): value is readonly T[];
+/**
+ * Narrow an unknown value to `DataView`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `DataView`.
+ * @example
+ * ```ts
+ * isDataView(new DataView(new ArrayBuffer(8)))
+ * ```
+ */
+export declare function isDataView(value: DataView): boolean;
+export declare function isDataView(value: unknown): value is DataView;
+/**
+ * Narrow an unknown value to any `ArrayBufferView`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a typed array or `DataView`.
+ * @example
+ * ```ts
+ * isArrayBufferView(new Uint8Array(4))
+ * ```
+ */
+export declare function isArrayBufferView(value: ArrayBufferView): boolean;
+export declare function isArrayBufferView(value: unknown): value is ArrayBufferView;
+/**
+ * Narrow an unknown value to `Int8Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an `Int8Array`.
+ * @example
+ * ```ts
+ * isInt8Array(new Int8Array(1))
+ * ```
+ */
+export declare function isInt8Array(value: Int8Array): boolean;
+export declare function isInt8Array(value: unknown): value is Int8Array;
+/**
+ * Narrow an unknown value to `Uint8Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Uint8Array`.
+ * @example
+ * ```ts
+ * isUint8Array(new Uint8Array(1))
+ * ```
+ */
+export declare function isUint8Array(value: Uint8Array): boolean;
+export declare function isUint8Array(value: unknown): value is Uint8Array;
+/**
+ * Narrow an unknown value to `Uint8ClampedArray`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Uint8ClampedArray`.
+ * @example
+ * ```ts
+ * isUint8ClampedArray(new Uint8ClampedArray(1))
+ * ```
+ */
+export declare function isUint8ClampedArray(value: Uint8ClampedArray): boolean;
+export declare function isUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/**
+ * Narrow an unknown value to `Int16Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an `Int16Array`.
+ * @example
+ * ```ts
+ * isInt16Array(new Int16Array(1))
+ * ```
+ */
+export declare function isInt16Array(value: Int16Array): boolean;
+export declare function isInt16Array(value: unknown): value is Int16Array;
+/**
+ * Narrow an unknown value to `Uint16Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Uint16Array`.
+ * @example
+ * ```ts
+ * isUint16Array(new Uint16Array(1))
+ * ```
+ */
+export declare function isUint16Array(value: Uint16Array): boolean;
+export declare function isUint16Array(value: unknown): value is Uint16Array;
+/**
+ * Narrow an unknown value to `Int32Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an `Int32Array`.
+ * @example
+ * ```ts
+ * isInt32Array(new Int32Array(1))
+ * ```
+ */
+export declare function isInt32Array(value: Int32Array): boolean;
+export declare function isInt32Array(value: unknown): value is Int32Array;
+/**
+ * Narrow an unknown value to `Uint32Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Uint32Array`.
+ * @example
+ * ```ts
+ * isUint32Array(new Uint32Array(1))
+ * ```
+ */
+export declare function isUint32Array(value: Uint32Array): boolean;
+export declare function isUint32Array(value: unknown): value is Uint32Array;
+/**
+ * Narrow an unknown value to `Float32Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Float32Array`.
+ * @example
+ * ```ts
+ * isFloat32Array(new Float32Array(1))
+ * ```
+ */
+export declare function isFloat32Array(value: Float32Array): boolean;
+export declare function isFloat32Array(value: unknown): value is Float32Array;
+/**
+ * Narrow an unknown value to `Float64Array`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Float64Array`.
+ * @example
+ * ```ts
+ * isFloat64Array(new Float64Array(1))
+ * ```
+ */
+export declare function isFloat64Array(value: Float64Array): boolean;
+export declare function isFloat64Array(value: unknown): value is Float64Array;
+/**
+ * Narrow an unknown value to `BigInt64Array` when supported.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `BigInt64Array`.
+ * @example
+ * ```ts
+ * isBigInt64Array(typeof BigInt64Array === 'undefined' ? undefined : new BigInt64Array(1))
+ * ```
+ */
+export declare function isBigInt64Array(value: BigInt64Array): boolean;
+export declare function isBigInt64Array(value: unknown): value is BigInt64Array;
+/**
+ * Narrow an unknown value to `BigUint64Array` when supported.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `BigUint64Array`.
+ * @example
+ * ```ts
+ * isBigUint64Array(typeof BigUint64Array === 'undefined' ? undefined : new BigUint64Array(1))
+ * ```
+ */
+export declare function isBigUint64Array(value: BigUint64Array): boolean;
+export declare function isBigUint64Array(value: unknown): value is BigUint64Array;

package/dist/collections.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Narrow an unknown value to `Map`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Map`.
+ * @example
+ * ```ts
+ * isMap(new Map())
+ * ```
+ */
+export declare function isMap<K = unknown, V = unknown>(value: ReadonlyMap<K, V>): boolean;
+export declare function isMap<K = unknown, V = unknown>(value: unknown): value is ReadonlyMap<K, V>;
+/**
+ * Narrow an unknown value to `Set`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `Set`.
+ * @example
+ * ```ts
+ * isSet(new Set())
+ * ```
+ */
+export declare function isSet<T = unknown>(value: ReadonlySet<T>): boolean;
+export declare function isSet<T = unknown>(value: unknown): value is ReadonlySet<T>;
+/**
+ * Narrow an unknown value to `WeakMap`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `WeakMap`.
+ * @example
+ * ```ts
+ * isWeakMap(new WeakMap())
+ * ```
+ */
+export declare function isWeakMap(value: WeakMap<object, unknown>): boolean;
+export declare function isWeakMap(value: unknown): value is WeakMap<object, unknown>;
+/**
+ * Narrow an unknown value to `WeakSet`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `WeakSet`.
+ * @example
+ * ```ts
+ * isWeakSet(new WeakSet())
+ * ```
+ */
+export declare function isWeakSet(value: WeakSet<object>): boolean;
+export declare function isWeakSet(value: unknown): value is WeakSet<object>;
+/**
+ * Narrow an unknown value to a non-null object.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an object and not `null`.
+ * @example
+ * ```ts
+ * isObject({})
+ * ```
+ */
+export declare function isObject(value: object): boolean;
+export declare function isObject(value: unknown): value is object;
+/**
+ * Narrow an unknown value to a plain string-keyed record.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a non-array object.
+ * @example
+ * ```ts
+ * isRecord({ id: 'u1' })
+ * ```
+ */
+export declare function isRecord(value: Record<string, unknown>): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+import type { ValidationRuleName } from './types.js';
+/** Ordered evaluation of all built-in validation rules. */
+export declare const VALIDATION_RULE_NAMES: readonly ValidationRuleName[];
+/** Basic email format: local@domain.tld. */
+export declare const EMAIL_PATTERN: RegExp;
+/** HTTP or HTTPS URL. */
+export declare const URL_PATTERN: RegExp;
+/** Numeric value: integer or decimal, optionally negative. */
+export declare const NUMERIC_PATTERN: RegExp;
+/** Integer value, optionally negative. */
+export declare const INTEGER_PATTERN: RegExp;
+/** Letters and digits only. */
+export declare const ALPHANUMERIC_PATTERN: RegExp;

package/dist/emptiness.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Narrow an unknown value to the empty string.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is `''`.
+ * @example
+ * ```ts
+ * isEmptyString('')
+ * ```
+ */
+export declare function isEmptyString(value: unknown): value is '';
+/**
+ * Narrow an unknown value to an empty array.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an empty array.
+ * @example
+ * ```ts
+ * isEmptyArray([])
+ * ```
+ */
+export declare function isEmptyArray(value: []): boolean;
+export declare function isEmptyArray(value: unknown): value is readonly [];
+/**
+ * Narrow an unknown value to an empty plain object.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value has no enumerable string or symbol keys.
+ * @example
+ * ```ts
+ * isEmptyObject({})
+ * ```
+ */
+export declare function isEmptyObject(value: Record<string | symbol, never>): boolean;
+export declare function isEmptyObject(value: unknown): value is Record<string | symbol, never>;
+/**
+ * Narrow an unknown value to an empty map.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a map with size `0`.
+ * @example
+ * ```ts
+ * isEmptyMap(new Map())
+ * ```
+ */
+export declare function isEmptyMap(value: ReadonlyMap<never, never>): boolean;
+export declare function isEmptyMap(value: unknown): value is ReadonlyMap<never, never>;
+/**
+ * Narrow an unknown value to an empty set.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a set with size `0`.
+ * @example
+ * ```ts
+ * isEmptySet(new Set())
+ * ```
+ */
+export declare function isEmptySet(value: ReadonlySet<never>): boolean;
+export declare function isEmptySet(value: unknown): value is ReadonlySet<never>;
+/**
+ * Narrow an unknown value to a non-empty string.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a string with length greater than `0`.
+ * @example
+ * ```ts
+ * isNonEmptyString('value')
+ * ```
+ */
+export declare function isNonEmptyString(value: string): boolean;
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Narrow an unknown value to a non-empty array.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is an array with at least one item.
+ * @example
+ * ```ts
+ * isNonEmptyArray([1])
+ * ```
+ */
+export declare function isNonEmptyArray<T = unknown>(value: [T, ...T[]]): boolean;
+export declare function isNonEmptyArray<T = unknown>(value: unknown): value is readonly [T, ...T[]];
+/**
+ * Narrow an unknown value to a non-empty plain object.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value has at least one enumerable key.
+ * @example
+ * ```ts
+ * isNonEmptyObject({ id: '1' })
+ * ```
+ */
+export declare function isNonEmptyObject(value: Record<string | symbol, unknown>): boolean;
+export declare function isNonEmptyObject(value: unknown): value is Record<string | symbol, unknown>;
+/**
+ * Narrow an unknown value to a non-empty map.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a map with at least one entry.
+ * @example
+ * ```ts
+ * isNonEmptyMap(new Map([['a', 1]]))
+ * ```
+ */
+export declare function isNonEmptyMap<K = unknown, V = unknown>(value: ReadonlyMap<K, V>): boolean;
+export declare function isNonEmptyMap<K = unknown, V = unknown>(value: unknown): value is ReadonlyMap<K, V>;
+/**
+ * Narrow an unknown value to a non-empty set.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a set with at least one entry.
+ * @example
+ * ```ts
+ * isNonEmptySet(new Set([1]))
+ * ```
+ */
+export declare function isNonEmptySet<T = unknown>(value: ReadonlySet<T>): boolean;
+export declare function isNonEmptySet<T = unknown>(value: unknown): value is ReadonlySet<T>;

package/dist/errors.d.ts

@@ -0,0 +1,29 @@
+import type { ValidatorErrorCode, ValidatorErrorContext } from './types.js';
+/**
+ * Error thrown for invalid validator configuration.
+ *
+ * @param code - Machine-readable validator error code.
+ * @param message - Human-readable explanation.
+ * @param context - Additional error context.
+ * @returns A configured `ValidatorError` instance.
+ * @example
+ * ```ts
+ * throw new ValidatorError('INVALID_PATTERN', 'Pattern is invalid')
+ * ```
+ */
+export declare class ValidatorError extends Error {
+    readonly code: ValidatorErrorCode;
+    readonly context: ValidatorErrorContext;
+    constructor(code: ValidatorErrorCode, message: string, context?: ValidatorErrorContext);
+}
+/**
+ * Narrow an unknown value to `ValidatorError`.
+ *
+ * @param value - Value to test.
+ * @returns `true` when the value is a `ValidatorError`.
+ * @example
+ * ```ts
+ * isValidatorError(new ValidatorError('INVALID_RULES', 'Invalid rules'))
+ * ```
+ */
+export declare function isValidatorError(value: unknown): value is ValidatorError;

package/dist/factories.d.ts

@@ -0,0 +1,24 @@
+import type { Guard, GuardsShape, ShapeGuardResult } from './types.js';
+/**
+ * Normalize an enum-like object into its distinct public values.
+ *
+ * @param enumeration - Enum object or enum-like map.
+ * @returns A normalized list of accepted enum values.
+ * @example
+ * ```ts
+ * createEnumValues({ idle: 'IDLE', busy: 'BUSY' })
+ * ```
+ */
+export declare function createEnumValues<E extends Record<string, string | number>>(enumeration: E): readonly (string | number)[];
+/**
+ * Build an exact shape guard from a guard shape and optional-key configuration.
+ *
+ * @param shape - Guard shape to apply.
+ * @param optional - Optional keys, or `true` to make every key optional.
+ * @returns A guard enforcing exact string keys and per-property validation.
+ * @example
+ * ```ts
+ * const isUser = createShapeGuard({ id: isString })
+ * ```
+ */
+export declare function createShapeGuard<S extends GuardsShape, K extends Array<keyof S & string> | true | undefined>(shape: S, optional?: K): Guard<ShapeGuardResult<S, K>>;

package/dist/functions.d.ts

@@ -0,0 +1,85 @@
+import type { AnyAsyncFunction, AnyFunction, ZeroArgAsyncFunction, ZeroArgFunction } from './types.js';
+/**
+ * Narrow a function to one with no declared parameters.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function has zero declared parameters.
+ * @example
+ * ```ts
+ * isZeroArg(() => true)
+ * ```
+ */
+export declare function isZeroArg<F extends ZeroArgFunction>(value: F): value is F;
+export declare function isZeroArg(value: AnyFunction): value is ZeroArgFunction;
+/**
+ * Narrow a function to a native async function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is a native async function.
+ * @example
+ * ```ts
+ * isAsyncFunction(async () => true)
+ * ```
+ */
+export declare function isAsyncFunction<F extends AnyAsyncFunction>(value: F): value is F;
+export declare function isAsyncFunction(value: unknown): value is AnyAsyncFunction;
+/**
+ * Narrow a function to a generator function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is a generator function.
+ * @example
+ * ```ts
+ * isGeneratorFunction(function* () { yield 1 })
+ * ```
+ */
+export declare function isGeneratorFunction<F extends (...args: unknown[]) => Generator<unknown, unknown, unknown>>(value: F): value is F;
+export declare function isGeneratorFunction(value: unknown): value is (...args: unknown[]) => Generator<unknown, unknown, unknown>;
+/**
+ * Narrow a function to an async generator function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is an async generator function.
+ * @example
+ * ```ts
+ * isAsyncGeneratorFunction(async function* () { yield 1 })
+ * ```
+ */
+export declare function isAsyncGeneratorFunction<F extends (...args: unknown[]) => AsyncGenerator<unknown, unknown, unknown>>(value: F): value is F;
+export declare function isAsyncGeneratorFunction(value: unknown): value is (...args: unknown[]) => AsyncGenerator<unknown, unknown, unknown>;
+/**
+ * Narrow a function to a zero-argument async function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is async and has no declared parameters.
+ * @example
+ * ```ts
+ * isZeroArgAsync(async () => true)
+ * ```
+ */
+export declare function isZeroArgAsync<F extends ZeroArgAsyncFunction>(value: F): value is F;
+export declare function isZeroArgAsync(value: unknown): value is ZeroArgAsyncFunction;
+/**
+ * Narrow a function to a zero-argument generator function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is a generator with no declared parameters.
+ * @example
+ * ```ts
+ * isZeroArgGenerator(function* () { yield 1 })
+ * ```
+ */
+export declare function isZeroArgGenerator<F extends (...args: unknown[]) => Generator<unknown, unknown, unknown>>(value: F): value is F;
+export declare function isZeroArgGenerator(value: unknown): value is () => Generator<unknown, unknown, unknown>;
+/**
+ * Narrow a function to a zero-argument async generator function.
+ *
+ * @param value - Function to inspect.
+ * @returns `true` when the function is an async generator with no declared parameters.
+ * @example
+ * ```ts
+ * isZeroArgAsyncGenerator(async function* () { yield 1 })
+ * ```
+ */
+export declare function isZeroArgAsyncGenerator<F extends (...args: unknown[]) => AsyncGenerator<unknown, unknown, unknown>>(value: F): value is F;
+export declare function isZeroArgAsyncGenerator(value: unknown): value is () => AsyncGenerator<unknown, unknown, unknown>;