@hyperfixi/core 2.0.0

package/dist/types/template-types.d.ts

@@ -0,0 +1,162 @@
+import type { BaseTypedExpression, TypedExpressionContext, EvaluationResult, ValidationResult, LLMDocumentation } from './base-types';
+import type { HyperScriptValue } from './command-types';
+import type { ExecutionContext } from './core.ts';
+export interface TemplateExecutionContext extends TypedExpressionContext {
+    readonly templateBuffer: string[];
+    readonly templateDepth: number;
+    readonly iterationContext?: {
+        collection: HyperScriptValue;
+        currentIndex: number;
+        currentItem: HyperScriptValue;
+        totalItems: number;
+    };
+    readonly conditionalContext?: {
+        conditionMet: boolean;
+        elseAllowed: boolean;
+        branchExecuted: boolean;
+    } | undefined;
+    readonly templateMeta: {
+        templateName?: string;
+        compiledAt: number;
+        executionStartTime: number;
+        directiveStack: string[];
+    };
+}
+export type TemplateDirectiveType = '@if' | '@else' | '@repeat' | '@include' | '@end';
+export type TemplateRenderStrategy = 'replace' | 'append' | 'conditional' | 'iterate';
+export interface EnhancedTemplateDirective<TInput = unknown, TOutput = string> extends BaseTypedExpression<TOutput> {
+    readonly directiveType: TemplateDirectiveType;
+    readonly renderStrategy: TemplateRenderStrategy;
+    readonly createsScope: boolean;
+    readonly allowsNesting: boolean;
+    readonly allowedNext: TemplateDirectiveType[];
+    executeTemplate(context: TemplateExecutionContext, input: TInput, templateContent: string): Promise<EvaluationResult<string>>;
+    validateTemplateContext(context: TemplateExecutionContext, input: TInput): ValidationResult;
+}
+export declare const IfDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export interface IfDirectiveInput {
+    condition: unknown;
+    templateContent: string;
+}
+export declare const ElseDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export interface ElseDirectiveInput {
+    templateContent: string;
+}
+export declare const RepeatDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export interface RepeatDirectiveInput {
+    collection: unknown;
+    iteratorVariable?: string;
+    templateContent: string;
+}
+export interface EnhancedCompiledTemplate {
+    directives: EnhancedTemplateDirective[];
+    content: string[];
+    interpolations: Array<{
+        expression: string;
+        startIndex: number;
+        endIndex: number;
+        evaluatedType?: string;
+    }>;
+    metadata: {
+        originalTemplate: string;
+        compiledAt: number;
+        directiveCount: number;
+        interpolationCount: number;
+        estimatedComplexity: 'simple' | 'medium' | 'complex';
+    };
+    dependencies: {
+        requiredVariables: string[];
+        usedFeatures: string[];
+        nestedTemplates: string[];
+    };
+}
+export interface TemplateError {
+    readonly name: 'TemplateCompilationError' | 'TemplateExecutionError' | 'TemplateValidationError';
+    readonly message: string;
+    readonly code: string;
+    readonly templateName?: string;
+    readonly lineNumber?: number;
+    readonly columnNumber?: number;
+    readonly directiveType?: TemplateDirectiveType;
+    readonly suggestions: string[];
+    readonly context?: {
+        originalTemplate: string;
+        compiledDirectives: string[];
+        executionStack: string[];
+    };
+}
+export interface TemplatePerformanceMetrics {
+    readonly compilationTime: number;
+    readonly executionTime: number;
+    readonly renderTime: number;
+    readonly memoryUsage: number;
+    readonly cacheHits: number;
+    readonly cacheMisses: number;
+    readonly directiveExecutions: Record<TemplateDirectiveType, number>;
+}
+export interface EnhancedTemplateConfig {
+    enableCaching: boolean;
+    maxCacheSize: number;
+    enableMetrics: boolean;
+    enableValidation: boolean;
+    executionTimeout: number;
+    maxNestingDepth: number;
+    customDirectives: Record<string, EnhancedTemplateDirective>;
+    preprocessors: Array<(template: string) => string>;
+    postprocessors: Array<(result: string) => string>;
+}
+export interface TemplateContextBridge {
+    toTemplateContext(context: ExecutionContext, options?: {
+        templateName?: string;
+        initialBuffer?: string[];
+        iterationContext?: TemplateExecutionContext['iterationContext'];
+    }): TemplateExecutionContext;
+    fromTemplateContext(templateContext: TemplateExecutionContext, originalContext: ExecutionContext): ExecutionContext;
+}
+export interface TemplateDirectiveRegistry {
+    register<T extends EnhancedTemplateDirective>(directive: T): void;
+    get(directiveType: TemplateDirectiveType): EnhancedTemplateDirective | undefined;
+    has(directiveType: TemplateDirectiveType): boolean;
+    list(): TemplateDirectiveType[];
+    validate(directiveType: TemplateDirectiveType, input: unknown): ValidationResult;
+}
+export interface TemplateLLMDocumentation extends LLMDocumentation {
+    patterns: Array<{
+        name: string;
+        template: string;
+        context: Record<string, unknown>;
+        expectedOutput: string;
+        explanation: string;
+    }>;
+    combinations: Array<{
+        directives: TemplateDirectiveType[];
+        description: string;
+        example: string;
+        useCase: string;
+    }>;
+    troubleshooting: Array<{
+        error: string;
+        cause: string;
+        solution: string;
+        prevention: string;
+    }>;
+}
+export type TemplateStringLiteral<T extends string> = T;
+export type InterpolationPattern = `\${${string}}`;
+export type DirectivePattern = `@${string}`;
+export type TemplateDataTypes = string | number | boolean | null | undefined | Array<string | number | boolean | null | undefined | Record<string, unknown>> | Record<string, string | number | boolean | null | undefined | Array<unknown>>;
+export interface StandardTemplateContext {
+    readonly data: Record<string, TemplateDataTypes>;
+    readonly parent?: StandardTemplateContext;
+    readonly helpers: Record<string, (...args: unknown[]) => unknown>;
+    readonly partials: Record<string, string>;
+    readonly options: Record<string, unknown>;
+}
+export type { BaseTypedExpression, TypedExpressionContext, ExpressionMetadata, ValidationResult, LLMDocumentation, } from './expression-types';
+//# sourceMappingURL=template-types.d.ts.map

package/dist/types/type-guards.d.ts

@@ -0,0 +1,24 @@
+export declare function isInputElement(el: unknown): el is HTMLInputElement;
+export declare function isFormElement(el: unknown): el is HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export declare function isHTMLElement(el: unknown): el is HTMLElement;
+export declare function isDOMElement(value: unknown): value is Element;
+export declare function isDOMNode(value: unknown): value is Node;
+export declare function isOptionElement(el: unknown): el is HTMLOptionElement;
+export declare function isArrayLike(value: unknown): value is ArrayLike<unknown>;
+export declare function isNodeList(value: unknown): value is NodeList;
+export declare function isHTMLCollection(value: unknown): value is HTMLCollection;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isObject(value: unknown): value is object;
+export declare function isFunction(value: unknown): value is Function;
+export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;
+export declare function getProperty<T = unknown>(obj: unknown, key: string): T | undefined;
+export declare function setProperty<T = unknown>(obj: unknown, key: string, value: T): boolean;
+export declare function hasProperty(obj: unknown, key: string): boolean;
+export declare function toNumber(value: unknown): number | undefined;
+export declare function compareValues(left: unknown, right: unknown, op: '<' | '>' | '<=' | '>='): boolean | undefined;
+export declare function getFormValue(el: unknown): string | undefined;
+export declare function getChecked(el: unknown): boolean | undefined;
+export declare function getDisabled(el: unknown): boolean | undefined;
+export declare function getSelected(el: unknown): boolean | undefined;
+export declare function getHidden(el: unknown): boolean | undefined;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/types/unified-types.d.ts

@@ -0,0 +1,99 @@
+import type { RuntimeValidator } from '../validation/lightweight-validators';
+import type { ExecutionContext, ValidationError, ValidationResult } from './base-types';
+export type { CoreExecutionContext } from './core-context';
+export { createCoreContext, isCoreExecutionContext, assertHTMLElement, asHTMLElement, } from './core-context';
+export type { ValidationError, ValidationResult } from './base-types';
+export type HyperScriptValueType = 'string' | 'number' | 'boolean' | 'element' | 'element-list' | 'array' | 'object' | 'promise' | 'fragment' | 'null' | 'undefined' | 'function' | 'event' | 'error' | 'unknown';
+export type EvaluationType = HyperScriptValueType | 'Any' | 'Context' | 'Command' | 'Expression';
+export type HyperScriptValue = string | number | boolean | HTMLElement | HTMLElement[] | unknown[] | Record<string, unknown> | Promise<unknown> | DocumentFragment | null | undefined | Function | Event;
+export type { ExecutionContext, TypedExecutionContext } from './base-types';
+export interface Result<T = unknown> {
+    readonly success: boolean;
+    readonly value?: T;
+    readonly error?: {
+        readonly name: string;
+        readonly message: string;
+        readonly code?: string;
+        readonly suggestions?: string[];
+    };
+    readonly type?: string;
+}
+export interface TypedResult<T = unknown> extends Result<T> {
+    readonly errors?: ValidationError[];
+    readonly suggestions?: readonly string[] | string[];
+}
+export type CommandCategory = 'dom-manipulation' | 'event-handling' | 'data-processing' | 'control-flow' | 'animation' | 'network' | 'utility' | 'navigation' | 'templates' | 'advanced';
+export type SideEffect = 'dom-mutation' | 'network-request' | 'local-storage' | 'global-state' | 'event-emission' | 'timer-creation' | 'navigation' | 'dom-query' | 'history' | 'async' | 'attribute-transfer';
+export type ExpressionCategory = 'Reference' | 'Property' | 'Logical' | 'Mathematical' | 'Conversion' | 'Positional' | 'Special' | 'Template';
+export interface ExpressionMetadata {
+    readonly category: ExpressionCategory;
+    readonly complexity: 'simple' | 'medium' | 'complex';
+    readonly sideEffects?: SideEffect[];
+    readonly dependencies?: string[];
+    readonly returnTypes?: EvaluationType[];
+    readonly examples?: Array<{
+        readonly input: string;
+        readonly description: string;
+        readonly expectedOutput: unknown;
+        readonly context?: Partial<ExecutionContext>;
+    }>;
+    readonly relatedExpressions?: string[];
+    readonly performance?: {
+        readonly averageTime: number;
+        readonly complexity: string;
+    };
+}
+export interface ASTNode {
+    readonly type: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly start?: number;
+    readonly end?: number;
+    readonly raw?: string;
+    readonly [key: string]: unknown;
+}
+export interface ParseError {
+    readonly name?: string;
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+    readonly position?: number;
+    readonly source?: string;
+}
+export interface LLMDocumentation {
+    readonly summary: string;
+    readonly parameters: Array<{
+        readonly name: string;
+        readonly type: string;
+        readonly description: string;
+        readonly optional: boolean;
+        readonly examples: string[];
+    }>;
+    readonly returns: {
+        readonly type: string;
+        readonly description: string;
+        readonly examples: string[];
+    };
+    readonly examples: Array<{
+        readonly title: string;
+        readonly code: string;
+        readonly explanation: string;
+        readonly output: unknown;
+    }>;
+    readonly seeAlso: string[];
+    readonly tags: string[];
+}
+export declare class Validator {
+    static validateInput<T>(input: unknown, schema: RuntimeValidator<T>): ValidationResult<T>;
+    static createValidationError(type: ValidationError['type'], message: string, suggestions?: string[], path?: string, code?: string): ValidationError;
+    static createSuccessResult<T>(data: T): ValidationResult<T>;
+    static createErrorResult<T>(errors: ValidationError[], suggestions?: string[]): ValidationResult<T>;
+}
+export declare function isValidationResult<T>(value: unknown): value is ValidationResult<T>;
+export declare function isExecutionContext(value: unknown): value is ExecutionContext;
+export declare const CoreTypes: {
+    Validator: typeof Validator;
+    isValidationResult: typeof isValidationResult;
+    isExecutionContext: typeof isExecutionContext;
+};
+//# sourceMappingURL=unified-types.d.ts.map

package/dist/utils/debug-events.d.ts

@@ -0,0 +1,41 @@
+export interface SemanticParseEventDetail {
+    input: string;
+    language: string;
+    confidence: number;
+    threshold: number;
+    semanticSuccess: boolean;
+    fallbackTriggered: boolean;
+    command?: string;
+    roles?: Record<string, string>;
+    errors?: string[];
+    timestamp: number;
+    duration?: number;
+}
+export interface ParseCompleteEventDetail {
+    input: string;
+    method: 'semantic' | 'traditional' | 'expression';
+    success: boolean;
+    command?: string;
+    errors?: string[];
+    timestamp: number;
+    duration?: number;
+}
+export declare function enableDebugEvents(target?: EventTarget): void;
+export declare function disableDebugEvents(): void;
+export declare function isDebugEnabled(): boolean;
+export declare function emitSemanticParseEvent(detail: SemanticParseEventDetail): void;
+export declare function emitParseCompleteEvent(detail: ParseCompleteEventDetail): void;
+export interface DebugStats {
+    totalParses: number;
+    semanticSuccesses: number;
+    semanticFallbacks: number;
+    traditionalParses: number;
+    averageConfidence: number;
+    confidenceHistory: number[];
+}
+export declare function updateDebugStats(event: SemanticParseEventDetail): void;
+export declare function getDebugStats(): Readonly<DebugStats>;
+export declare function resetDebugStats(): void;
+export declare function getEventHistory(): readonly SemanticParseEventDetail[];
+export declare function replayEvents(callback: (event: SemanticParseEventDetail) => void): void;
+//# sourceMappingURL=debug-events.d.ts.map

package/dist/utils/debug.d.ts

@@ -0,0 +1,35 @@
+export declare const DEBUG: {
+    commands: boolean;
+    events: boolean;
+    parsing: boolean;
+    expressions: boolean;
+    styles: boolean;
+    runtime: boolean;
+    loops: boolean;
+    async: boolean;
+};
+export declare const debug: {
+    command: (...args: any[]) => void;
+    event: (...args: any[]) => void;
+    parse: (...args: any[]) => void;
+    expr: (...args: any[]) => void;
+    expressions: (...args: any[]) => void;
+    style: (...args: any[]) => void;
+    runtime: (...args: any[]) => void;
+    loop: (...args: any[]) => void;
+    async: (...args: any[]) => void;
+};
+export declare const debugGroup: {
+    start: (label: string) => void;
+    end: () => void;
+};
+export declare const debugControl: {
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    status(): {
+        enabled: boolean;
+        source: string;
+    };
+};
+//# sourceMappingURL=debug.d.ts.map

package/dist/utils/dom-utils.d.ts

@@ -0,0 +1,16 @@
+import type { TypedExecutionContext } from '../types/command-types.ts';
+export declare function asHTMLElement(element: Element | null): HTMLElement | null;
+export declare function asHTMLElement(element: Element | undefined): HTMLElement | undefined;
+export declare function requireHTMLElement(element: Element | null | undefined, context?: string): HTMLElement;
+export declare function asHTMLElements(elements: Element[]): HTMLElement[];
+export declare function isHTMLElement(element: Element | null | undefined): element is HTMLElement;
+export interface ResolveTargetsOptions {
+    allowEmpty?: boolean;
+    contextRequired?: boolean;
+}
+export declare function resolveTargets(context: TypedExecutionContext, target?: unknown, options?: ResolveTargetsOptions): HTMLElement[];
+export declare function isValidClassName(className: string): boolean;
+export declare function parseClasses(classExpression: unknown, validate?: boolean): string[];
+export declare function isValidAttributeName(name: string): boolean;
+export declare function isValidCSSSelector(selector: string): boolean;
+//# sourceMappingURL=dom-utils.d.ts.map

package/dist/utils/element-check.d.ts

@@ -0,0 +1,7 @@
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+export declare function isNode(value: unknown): value is Node;
+export declare function isElement(value: unknown): value is Element;
+export declare function isEventTarget(value: unknown): value is EventTarget;
+export declare function isNodeList(value: unknown): value is NodeList;
+export declare function isDocumentFragment(value: unknown): value is DocumentFragment;
+//# sourceMappingURL=element-check.d.ts.map

package/dist/utils/keyboard-shortcuts.d.ts

@@ -0,0 +1,18 @@
+export interface KeyboardShortcut {
+    key: string;
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+    originalSyntax: string;
+}
+export declare function parseKeyboardShortcut(syntax: string): KeyboardShortcut | null;
+export declare function createKeyboardFilter(shortcut: KeyboardShortcut): (event: KeyboardEvent) => boolean;
+export declare function createFilterExpression(shortcut: KeyboardShortcut): string;
+export declare function transformKeyboardEvent(eventType: string): {
+    type: string;
+    filter?: string;
+};
+export declare function isKeyboardShortcut(syntax: string): boolean;
+export declare function getShortcutDescription(shortcut: KeyboardShortcut): string;
+//# sourceMappingURL=keyboard-shortcuts.d.ts.map

package/dist/utils/performance.d.ts

@@ -0,0 +1,40 @@
+export interface PoolMetrics {
+    allocations: number;
+    reuses: number;
+    peakPoolSize: number;
+    hitRate: number;
+}
+export declare class ObjectPool<T extends object> {
+    private pool;
+    private index;
+    private factory;
+    private reset;
+    private metrics;
+    constructor(factory: () => T, reset?: (obj: T) => void, initialSize?: number);
+    get(): T;
+    releaseAll(): void;
+    getMetrics(): PoolMetrics;
+    clear(): void;
+}
+export declare class StyleBatcher {
+    private pending;
+    private rafId;
+    private stylePool;
+    add(element: HTMLElement, styles: Record<string, string>): void;
+    private flush;
+    cancel(): void;
+    getPendingCount(): number;
+    getPoolMetrics(): PoolMetrics;
+}
+export declare const styleBatcher: StyleBatcher;
+export declare class EventQueue {
+    private listeners;
+    wait(eventName: string, target: EventTarget): Promise<Event>;
+    private setupListener;
+    private getKey;
+    cleanup(target: EventTarget, eventName: string): void;
+    cleanupAll(): void;
+    getListenerCount(): number;
+}
+export declare const eventQueue: EventQueue;
+//# sourceMappingURL=performance.d.ts.map

package/dist/validation/command-pattern-validator.d.ts

@@ -0,0 +1,53 @@
+export interface PatternValidationResult {
+    isEnhanced: boolean;
+    score: number;
+    passed: string[];
+    failed: string[];
+    suggestions: string[];
+    details: {
+        hasCorrectInterface: boolean;
+        hasRequiredProperties: boolean;
+        hasProperMetadata: boolean;
+        hasValidation: boolean;
+        hasFactoryFunction: boolean;
+        hasBundleAnnotations: boolean;
+        hasAsyncExecute: boolean;
+    };
+}
+export interface CommandAnalysis {
+    commandName: string;
+    filePath: string;
+    validation: PatternValidationResult;
+    recommendations: string[];
+}
+export declare class CommandPatternValidator {
+    static validateCommand(CommandClass: new () => unknown, factoryFunction?: Function, sourceCode?: string): PatternValidationResult;
+    private static validateInterface;
+    private static validateRequiredProperties;
+    private static validateMetadataQuality;
+    private static validateValidationMethod;
+    private static validateBundleAnnotations;
+    private static validateAsyncExecute;
+}
+export declare class CommandSuiteValidator {
+    static validateCommandSuite(commands: Array<{
+        name: string;
+        filePath: string;
+        CommandClass: any;
+        factoryFunction?: Function;
+    }>): Promise<{
+        overall: {
+            total: number;
+            enhanced: number;
+            averageScore: number;
+            needsWork: number;
+        };
+        commands: CommandAnalysis[];
+        recommendations: string[];
+    }>;
+}
+export declare class ValidationReporter {
+    static printCommandValidation(analysis: CommandAnalysis): void;
+    static printSuiteValidation(result: Awaited<ReturnType<typeof CommandSuiteValidator.validateCommandSuite>>): void;
+}
+//# sourceMappingURL=command-pattern-validator.d.ts.map

package/dist/validation/common-validators.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeValidator } from './lightweight-validators';
+export declare const htmlElement: RuntimeValidator<HTMLElement>;
+export declare const htmlElementArray: RuntimeValidator<HTMLElement[]>;
+export declare const htmlElementOrNull: RuntimeValidator<HTMLElement | null | undefined>;
+export declare const elementTarget: RuntimeValidator<HTMLElement | HTMLElement[] | string | null | undefined>;
+export declare const nodeList: RuntimeValidator<NodeList>;
+export declare const htmlCollection: RuntimeValidator<HTMLCollection>;
+export declare const cssSelector: RuntimeValidator<string>;
+export declare const cssClassName: RuntimeValidator<string>;
+export declare const attributeName: RuntimeValidator<string>;
+export declare const eventName: RuntimeValidator<string>;
+export declare const validators: {
+    htmlElement: RuntimeValidator<HTMLElement>;
+    htmlElementArray: RuntimeValidator<HTMLElement[]>;
+    htmlElementOrNull: RuntimeValidator<HTMLElement | null | undefined>;
+    elementTarget: RuntimeValidator<string | HTMLElement | HTMLElement[] | null | undefined>;
+    nodeList: RuntimeValidator<NodeList>;
+    htmlCollection: RuntimeValidator<HTMLCollection>;
+    cssSelector: RuntimeValidator<string>;
+    cssClassName: RuntimeValidator<string>;
+    attributeName: RuntimeValidator<string>;
+    eventName: RuntimeValidator<string>;
+};
+//# sourceMappingURL=common-validators.d.ts.map

package/dist/validation/lightweight-validators.d.ts

@@ -0,0 +1,113 @@
+import type { ValidationError } from '../types/base-types';
+export interface ValidationResult<T = unknown> {
+    success: boolean;
+    data?: T | undefined;
+    error?: ValidationError | undefined;
+}
+export interface RuntimeValidator<T = unknown> {
+    validate(value: unknown): ValidationResult<T>;
+    safeParse(value: unknown): {
+        success: boolean;
+        data?: T;
+        error?: {
+            errors: ValidationError[];
+        };
+    };
+    description?: string;
+    describe(description: string): RuntimeValidator<T>;
+    strict(): RuntimeValidator<T>;
+    optional(): RuntimeValidator<T | undefined>;
+    default(value: T): RuntimeValidator<T>;
+    min(value: number): RuntimeValidator<T>;
+    max(value: number): RuntimeValidator<T>;
+    url(): RuntimeValidator<T>;
+    email(): RuntimeValidator<T>;
+    uuid(): RuntimeValidator<T>;
+    regex(pattern: RegExp): RuntimeValidator<T>;
+    date(): RuntimeValidator<T>;
+    rest(): RuntimeValidator<T>;
+    parse(value: unknown): T;
+    merge(other: RuntimeValidator<any>): RuntimeValidator<T>;
+    refine(refineFn: (value: T) => boolean, errorMessage?: string): RuntimeValidator<T>;
+    _defaultValue?: T;
+    _isOptional?: boolean;
+    _baseValidator?: RuntimeValidator<any>;
+}
+export interface StringValidatorOptions {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    optional?: boolean;
+    description?: string;
+}
+export declare function createStringValidator(options?: StringValidatorOptions): RuntimeValidator<string>;
+export declare function createObjectValidator<T extends Record<string, RuntimeValidator>>(fields: T, options?: {
+    strict?: boolean;
+} | undefined): RuntimeValidator<{
+    [K in keyof T]: T[K] extends RuntimeValidator<infer U> ? U : never;
+}>;
+export declare function createArrayValidator<T>(itemValidator: RuntimeValidator<T>): RuntimeValidator<T[]>;
+export declare function createTupleValidator<T extends readonly RuntimeValidator[]>(validators: T): RuntimeValidator<{
+    [K in keyof T]: T[K] extends RuntimeValidator<infer U> ? U : never;
+}>;
+export declare function createUnionValidator<T>(validators: RuntimeValidator<T>[]): RuntimeValidator<T>;
+export declare function createLiteralValidator<T extends string | number | boolean>(literalValue: T): RuntimeValidator<T>;
+export declare function createNumberValidator(options?: {
+    min?: number;
+    max?: number;
+}): RuntimeValidator<number>;
+export declare function createBooleanValidator(): RuntimeValidator<boolean>;
+export declare function createCustomValidator<T>(validator: (value: unknown) => boolean, errorMessage?: string): RuntimeValidator<T>;
+export declare function createRecordValidator<K extends string | number | symbol, V>(keyValidator: RuntimeValidator<K>, valueValidator: RuntimeValidator<V>): RuntimeValidator<Record<K, V>>;
+export declare function createEnumValidator<T extends readonly string[]>(values: T): RuntimeValidator<T[number]>;
+export declare const v: {
+    string: (options?: StringValidatorOptions) => RuntimeValidator<string>;
+    number: (options?: {
+        min?: number;
+        max?: number;
+    }) => RuntimeValidator<number>;
+    boolean: () => RuntimeValidator<boolean>;
+    object: (fields: any) => RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    array: (itemValidator: any) => RuntimeValidator<unknown[]>;
+    tuple: (validators: any) => RuntimeValidator<unknown[]>;
+    union: (validators: any) => RuntimeValidator<unknown>;
+    literal: (value: any) => RuntimeValidator<any>;
+    custom: (validator: any, errorMessage?: string) => RuntimeValidator<unknown>;
+    record: (keyValidator: any, valueValidator: any) => RuntimeValidator<Record<string | number | symbol, unknown>>;
+    enum: (values: readonly string[]) => RuntimeValidator<string>;
+    function: () => RuntimeValidator<unknown>;
+    unknown: () => RuntimeValidator<unknown>;
+    any: () => RuntimeValidator<any>;
+    null: () => RuntimeValidator<unknown>;
+    undefined: () => RuntimeValidator<unknown>;
+    instanceOf: (constructor: any) => RuntimeValidator<unknown>;
+    instanceof: (constructor: any) => RuntimeValidator<unknown>;
+};
+export declare const z: {
+    string: (options?: StringValidatorOptions) => RuntimeValidator<string>;
+    number: (options?: {
+        min?: number;
+        max?: number;
+    }) => RuntimeValidator<number>;
+    boolean: () => RuntimeValidator<boolean>;
+    object: (fields: any) => RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    array: (itemValidator: any) => RuntimeValidator<unknown[]>;
+    tuple: (validators: any) => RuntimeValidator<unknown[]>;
+    union: (validators: any) => RuntimeValidator<unknown>;
+    literal: (value: any) => RuntimeValidator<any>;
+    custom: (validator: any, errorMessage?: string) => RuntimeValidator<unknown>;
+    record: (keyValidator: any, valueValidator: any) => RuntimeValidator<Record<string | number | symbol, unknown>>;
+    enum: (values: readonly string[]) => RuntimeValidator<string>;
+    function: () => RuntimeValidator<unknown>;
+    unknown: () => RuntimeValidator<unknown>;
+    any: () => RuntimeValidator<any>;
+    null: () => RuntimeValidator<unknown>;
+    undefined: () => RuntimeValidator<unknown>;
+    instanceOf: (constructor: any) => RuntimeValidator<unknown>;
+    instanceof: (constructor: any) => RuntimeValidator<unknown>;
+};
+//# sourceMappingURL=lightweight-validators.d.ts.map