model-validator-ts/dist/index.d.ts

[](https://www.npmjs.com/package/model-validator-ts)

import type { StandardSchemaV1 } from "./standard-schema.ts";
type TValidationDeps = object;
type ErrorBagFromInput<TInput> = ErrorBag<Exclude<keyof TInput, symbol | number>>;
type ErrorBagFromSchema<TSchema extends StandardSchemaV1> = ErrorBag<Exclude<keyof StandardSchemaV1.InferOutput<TSchema>, symbol | number>>;
export declare class ErrorBag<TKeys extends string> {
    #private;
    addGlobalError(message: string): this;
    addError(key: TKeys, message: string): this;
    get global(): string | undefined;
    firstError(key: TKeys): string | undefined;
    hasErrors(): boolean;
    toObject(): {
        global: string | undefined;
        issues: Partial<Record<TKeys, string[]>>;
    };
}
type ValidationOpts<TInput> = {
    validationType?: "plain";
    override?: Partial<TInput>;
};
type ContextRuleFunction<TInput, TDeps extends TValidationDeps = {}, TInputContext = {}, TReturn = {}> = (args: {
    data: TInput;
    deps: TDeps;
    bag: ErrorBagFromInput<TInput>;
    context: TInputContext;
}) => TReturn | Promise<TReturn> | void | Promise<void>;
type ContextRuleDefinition<TInput, TDeps extends TValidationDeps = {}, TInputContext = {}, TReturn = {}> = {
    fn: ContextRuleFunction<TInput, TDeps, TInputContext, TReturn>;
    description?: string;
    id?: string;
};
export type CommandResult<TOutput, TInput, TContext> = {
    success: true;
    result: Exclude<TOutput, ErrorBag<any> | void>;
    context: TContext;
} | {
    success: false;
    errors: ErrorBagFromInput<TInput>;
    step: "validation" | "execution";
    rule?: {
        id?: string;
        description?: string;
    };
};
type ExtractContext<T> = T extends {
    context: infer TContext;
} ? TContext : never;
type NonVoidReturnContext<TReturn> = TReturn extends void | Promise<void> ? never : ExtractContext<TReturn>;
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
type DepsStatus = "not-required" | "required" | "passed";
export declare class Command<TSchema extends StandardSchemaV1, TDeps extends TValidationDeps, TContext, TOutput, TDepsStatus extends DepsStatus> {
    #private;
    constructor(validatorBuilder: FluentValidatorBuilder<TSchema, TDeps, TContext, TDepsStatus>, execute: (params: {
        data: StandardSchemaV1.InferOutput<TSchema>;
        deps: TDeps;
        context: TContext;
        bag: ErrorBagFromSchema<TSchema>;
    }) => Promise<TOutput> | TOutput);
    provide(this: Command<TSchema, TDeps, TContext, TOutput, "required">, deps: TDeps): Command<TSchema, TDeps, TContext, TOutput, "passed">;
    run: TDepsStatus extends "required" ? never : (input: unknown, opts?: ValidationOpts<StandardSchemaV1.InferInput<TSchema>>) => Promise<CommandResult<TOutput, StandardSchemaV1.InferInput<TSchema>, TContext>>;
    runShape: TDepsStatus extends "required" ? never : (input: StandardSchemaV1.InferInput<TSchema>, opts?: ValidationOpts<StandardSchemaV1.InferInput<TSchema>>) => Promise<CommandResult<TOutput, StandardSchemaV1.InferInput<TSchema>, TContext>>;
}
type FluentValidatorBuilderState<TSchema extends StandardSchemaV1, TDeps extends TValidationDeps> = {
    schema: TSchema | undefined;
    deps: TDeps | undefined;
    contextRules: Array<ContextRuleDefinition<any, any, any, any>>;
    depsStatus: DepsStatus;
};
export declare class FluentValidatorBuilder<TSchema extends StandardSchemaV1 = any, TDeps extends TValidationDeps = {}, TContext = {}, TDpesStatus extends DepsStatus = "not-required"> {
    #private;
    constructor(state?: FluentValidatorBuilderState<TSchema, TDeps>);
    input<T extends StandardSchemaV1>(schema: T): FluentValidatorBuilder<T, TDeps, TContext, TDpesStatus>;
    $deps<T extends TValidationDeps>(): FluentValidatorBuilder<TSchema, T, TContext, "required">;
    get ["~unsafeInternals"](): FluentValidatorBuilderState<TSchema, TDeps>;
    validate: TDpesStatus extends "required" ? never : (input: unknown, opts?: ValidationOpts<StandardSchemaV1.InferInput<TSchema>>) => Promise<{
        success: true;
        value: StandardSchemaV1.InferOutput<TSchema>;
        context: TContext;
    } | {
        success: false;
        errors: ErrorBagFromSchema<TSchema>;
        rule?: {
            id?: string;
            description?: string;
        };
    }>;
    rule<TReturn>(rule: ContextRuleDefinition<StandardSchemaV1.InferOutput<TSchema>, TDeps, TContext, TReturn>): FluentValidatorBuilder<TSchema, TDeps, NonVoidReturnContext<TReturn> extends never ? TContext : Prettify<TContext & NonVoidReturnContext<TReturn>>, TDpesStatus>;
    provide(this: FluentValidatorBuilder<TSchema, TDeps, TContext, "required">, deps: TDeps): FluentValidatorBuilder<TSchema, TDeps, TContext, "passed">;
    command<TOutput>(args: {
        execute: (params: {
            data: StandardSchemaV1.InferOutput<TSchema>;
            deps: TDeps;
            context: TContext;
            bag: ErrorBagFromSchema<TSchema>;
        }) => Promise<TOutput> | TOutput;
    }): Command<TSchema, TDeps, TContext, TOutput, TDpesStatus>;
}
export declare function buildValidator(): FluentValidatorBuilder<any, {}, {}, "not-required">;
export type InferCommandResult<TCommand extends Command<any, any, any, any, any>, TCondition extends "success" | "failure" | "all" = "all"> = TCommand extends Command<infer TSchema, any, infer TContext, infer TOutput, any> ? TCondition extends "success" ? CommandResult<TOutput, StandardSchemaV1.InferInput<TSchema>, TContext> & {
    success: true;
} : TCondition extends "failure" ? CommandResult<TOutput, StandardSchemaV1.InferInput<TSchema>, TContext> & {
    success: false;
} : CommandResult<TOutput, StandardSchemaV1.InferInput<TSchema>, TContext> : never;
export {};
//# sourceMappingURL=index.d.ts.map