@zeruxjs/validator 0.0.0-stage → 0.0.1

package/dist/types/pipe.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipe.js.map

package/dist/types/pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.js","sourceRoot":"","sources":["../../src/types/pipe.ts"],"names":[],"mappings":""}

package/dist/types/schema.d.ts

@@ -0,0 +1,88 @@
+import type { Config } from './config.js';
+import type { OutputDataset, UnknownDataset } from './dataset.js';
+import type { BaseIssue } from './issue.js';
+import type { StandardProps } from './standard.js';
+/**
+ * Base schema interface.
+ */
+export interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The schema type.
+     */
+    readonly type: string;
+    /**
+     * The schema reference.
+     */
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<TInput, TOutput>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base schema async interface.
+ */
+export interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+    /**
+     * The schema reference.
+     */
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
+}
+/**
+ * Generic schema type.
+ */
+export type GenericSchema<TInput = unknown, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue>;
+/**
+ * Generic schema async type.
+ */
+export type GenericSchemaAsync<TInput = unknown, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue>;

package/dist/types/schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.js.map

package/dist/types/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/types/schema.ts"],"names":[],"mappings":""}

package/dist/types/standard.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The Standard Schema properties interface.
+ */
+export interface StandardProps<TInput, TOutput> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: '@zeruxjs/validator';
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: StandardTypes<TInput, TOutput> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+export type StandardResult<TOutput> = StandardSuccessResult<TOutput> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+export interface StandardSuccessResult<TOutput> {
+    /**
+     * The typed output value.
+     */
+    readonly value: TOutput;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+export interface StandardFailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: readonly StandardIssue[];
+}
+/**
+ * The issue interface of the failure output.
+ */
+export interface StandardIssue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
+}
+/**
+ * The path item interface of the issue.
+ */
+export interface StandardPathItem {
+    /**
+     * The key of the path item.
+     */
+    readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+export interface StandardTypes<TInput, TOutput> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: TInput;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: TOutput;
+}

package/dist/types/standard.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=standard.js.map

package/dist/types/standard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard.js","sourceRoot":"","sources":["../../src/types/standard.ts"],"names":[],"mappings":""}

package/dist/types/transformation.d.ts

@@ -0,0 +1,77 @@
+import type { Config } from './config.js';
+import type { OutputDataset, SuccessDataset } from './dataset.js';
+import type { BaseIssue } from './issue.js';
+/**
+ * Base transformation interface.
+ */
+export interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'transformation';
+    /**
+     * The transformation type.
+     */
+    readonly type: string;
+    /**
+     * The transformation reference.
+     */
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base transformation async interface.
+ */
+export interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+    /**
+     * The transformation reference.
+     */
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+/**
+ * Generic transformation type.
+ */
+export type GenericTransformation<TInput = any, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseTransformation<TInput, TOutput, TIssue>;
+/**
+ * Generic transformation async type.
+ */
+export type GenericTransformationAsync<TInput = any, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseTransformationAsync<TInput, TOutput, TIssue>;

package/dist/types/transformation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transformation.js.map

package/dist/types/transformation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformation.js","sourceRoot":"","sources":["../../src/types/transformation.ts"],"names":[],"mappings":""}

package/dist/types/tuple.d.ts

@@ -0,0 +1,28 @@
+import type { InferInput, InferIssue, InferOutput } from './infer.js';
+import type { BaseIssue } from './issue.js';
+import type { BaseSchema, BaseSchemaAsync } from './schema.js';
+import type { MaybeReadonly } from './utils.js';
+/**
+ * Tuple items type.
+ */
+export type TupleItems = MaybeReadonly<BaseSchema<unknown, unknown, BaseIssue<unknown>>[]>;
+/**
+ * Tuple items async type.
+ */
+export type TupleItemsAsync = MaybeReadonly<(BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>)[]>;
+/**
+ * Infer tuple input type.
+ */
+export type InferTupleInput<TItems extends TupleItems | TupleItemsAsync> = {
+    -readonly [TKey in keyof TItems]: InferInput<TItems[TKey]>;
+};
+/**
+ * Infer tuple output type.
+ */
+export type InferTupleOutput<TItems extends TupleItems | TupleItemsAsync> = {
+    -readonly [TKey in keyof TItems]: InferOutput<TItems[TKey]>;
+};
+/**
+ * Infer tuple issue type.
+ */
+export type InferTupleIssue<TItems extends TupleItems | TupleItemsAsync> = InferIssue<TItems[number]>;

package/dist/types/tuple.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tuple.js.map

package/dist/types/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../src/types/tuple.ts"],"names":[],"mappings":""}

package/dist/types/utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Checks if a type is `any`.
+ */
+export type IsAny<Type> = 0 extends 1 & Type ? true : false;
+/**
+ * Checks if a type is `never`.
+ */
+export type IsNever<Type> = [Type] extends [never] ? true : false;
+/**
+ * Extracts `null` from a type.
+ */
+export type NonNullable<TValue> = TValue extends null ? never : TValue;
+/**
+ * Extracts `null` and `undefined` from a type.
+ */
+export type NonNullish<TValue> = TValue extends null | undefined ? never : TValue;
+/**
+ * Extracts `undefined` from a type.
+ */
+export type NonOptional<TValue> = TValue extends undefined ? never : TValue;
+/**
+ * Constructs a type that is maybe readonly.
+ */
+export type MaybeReadonly<TValue> = TValue | Readonly<TValue>;
+/**
+ * Constructs a type that is deeply readonly.
+ */
+export type DeepReadonly<TValue> = TValue extends Record<string, unknown> | readonly unknown[] ? {
+    readonly [TKey in keyof TValue]: DeepReadonly<TValue[TKey]>;
+} : TValue;
+/**
+ * Constructs a type that is maybe deeply readonly.
+ */
+export type MaybeDeepReadonly<TValue> = TValue | DeepReadonly<TValue>;
+/**
+ * Constructs a type that is maybe a promise.
+ */
+export type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+ * Prettifies a type for better readability.
+ *
+ * Hint: This type has no effect and is only used so that TypeScript displays
+ * the final type in the preview instead of the utility types used.
+ */
+export type Prettify<TObject> = {
+    [TKey in keyof TObject]: TObject[TKey];
+} & {};
+/**
+ * Marks specific keys as optional.
+ */
+export type MarkOptional<TObject, TKeys extends keyof TObject> = {
+    [TKey in keyof TObject]?: unknown;
+} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Merges two objects. Overlapping entries from the second object overwrite
+ * properties from the first object.
+ */
+export type Merge<TFirstObject, TSecondObject> = Omit<TFirstObject, keyof TFirstObject & keyof TSecondObject> & TSecondObject;
+/**
+ * Extracts first tuple item.
+ */
+export type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+export type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [unknown, ...infer TRest] ? TRest['length'] : never];
+/**
+ * Converts union to intersection type.
+ */
+export type UnionToIntersect<TUnion> = (TUnion extends any ? (arg: TUnion) => void : never) extends (arg: infer Intersect) => void ? Intersect : never;
+/**
+ * Converts union to tuple type using an accumulator.
+ *
+ * For more information: {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types}
+ */
+type UnionToTupleHelper<TUnion, TResult extends unknown[]> = UnionToIntersect<TUnion extends never ? never : () => TUnion> extends () => infer TLast ? UnionToTupleHelper<Exclude<TUnion, TLast>, [TLast, ...TResult]> : TResult;
+/**
+ * Converts union to tuple type.
+ */
+export type UnionToTuple<TUnion> = UnionToTupleHelper<TUnion, []>;
+export {};

package/dist/types/utils.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.js.map

package/dist/types/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/types/utils.ts"],"names":[],"mappings":""}

package/dist/types/validation.d.ts

@@ -0,0 +1,81 @@
+import type { Config } from './config.js';
+import type { OutputDataset } from './dataset.js';
+import type { BaseIssue } from './issue.js';
+/**
+ * Base validation interface.
+ */
+export interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'validation';
+    /**
+     * The validation type.
+     */
+    readonly type: string;
+    /**
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string | null;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base validation async interface.
+ */
+export interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~run'> {
+    /**
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+/**
+ * Generic validation type.
+ */
+export type GenericValidation<TInput = any, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseValidation<TInput, TOutput, TIssue>;
+/**
+ * Generic validation async type.
+ */
+export type GenericValidationAsync<TInput = any, TOutput = TInput, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseValidationAsync<TInput, TOutput, TIssue>;

package/dist/types/validation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.js.map

package/dist/types/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/types/validation.ts"],"names":[],"mappings":""}

package/dist/utils/ValidationError.d.ts

@@ -0,0 +1,41 @@
+import type { BaseIssue, BaseSchema, BaseSchemaAsync, InferIssue } from '../types/index.js';
+import { type FormattedIssueTree } from './formatIssues.js';
+/**
+ * A error with useful information.
+ */
+export declare class ValidationError<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> extends Error {
+    /**
+     * The error issues.
+     */
+    readonly issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]];
+    readonly summary: string;
+    /**
+     * Creates a error with useful information.
+     *
+     * @param issues The error issues.
+     */
+    constructor(issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]]);
+    flatten(): {
+        readonly root?: [string, ...string[]] | undefined;
+        readonly nested?: {
+            readonly [x: string]: [string, ...string[]] | undefined;
+        } | undefined;
+        readonly other?: [string, ...string[]] | undefined;
+    };
+    format(): FormattedIssueTree;
+    summarize(): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        summary: string;
+        issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]];
+        flat: {
+            readonly root?: [string, ...string[]] | undefined;
+            readonly nested?: {
+                readonly [x: string]: [string, ...string[]] | undefined;
+            } | undefined;
+            readonly other?: [string, ...string[]] | undefined;
+        };
+        formatted: FormattedIssueTree;
+    };
+}

package/dist/utils/ValidationError.js

@@ -0,0 +1,46 @@
+import { flatten } from '../methods/flatten.js';
+import { summarize } from '../methods/summarize.js';
+import { formatIssues } from './formatIssues.js';
+/**
+ * A error with useful information.
+ */
+export class ValidationError extends Error {
+    /**
+     * The error issues.
+     */
+    issues;
+    summary;
+    /**
+     * Creates a error with useful information.
+     *
+     * @param issues The error issues.
+     */
+    // @__NO_SIDE_EFFECTS__
+    constructor(issues) {
+        const summary = summarize(issues);
+        super(issues.length === 1 ? issues[0].message : summary, { cause: issues });
+        this.name = 'ValidationError';
+        this.issues = issues;
+        this.summary = summary;
+    }
+    flatten() {
+        return flatten(this.issues);
+    }
+    format() {
+        return formatIssues(this.issues);
+    }
+    summarize() {
+        return this.summary;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            summary: this.summary,
+            issues: this.issues,
+            flat: this.flatten(),
+            formatted: this.format(),
+        };
+    }
+}
+//# sourceMappingURL=ValidationError.js.map

package/dist/utils/ValidationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationError.js","sourceRoot":"","sources":["../../src/utils/ValidationError.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,YAAY,EAA2B,MAAM,mBAAmB,CAAC;AAE1E;;GAEG;AACH,MAAM,OAAO,eAIX,SAAQ,KAAK;IACb;;OAEG;IACa,MAAM,CAAkD;IACxD,OAAO,CAAS;IAEhC;;;;OAIG;IACH,uBAAuB;IACvB,YAAY,MAAuD;QACjE,MAAM,OAAO,GAAG,SAAS,CAAC,MAAuD,CAAC,CAAC;QACnF,KAAK,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,OAAO;QACL,OAAO,OAAO,CAAC,IAAI,CAAC,MAAuD,CAAC,CAAC;IAC/E,CAAC;IAED,MAAM;QACJ,OAAO,YAAY,CAAC,IAAI,CAAC,MAAuD,CAAC,CAAC;IACpF,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE;SACzB,CAAC;IACJ,CAAC;CACF"}

package/dist/utils/_addIssue.d.ts

@@ -0,0 +1,35 @@
+import type { BaseIssue, BaseSchema, BaseSchemaAsync, BaseTransformation, BaseTransformationAsync, BaseValidation, BaseValidationAsync, Config, ErrorMessage, InferInput, InferIssue, IssuePathItem, OutputDataset, UnknownDataset } from '../types/index.js';
+/**
+ * Context type.
+ */
+type Context = BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>>;
+/**
+ * Other interface.
+ */
+interface Other<TContext extends Context> {
+    input?: unknown | undefined;
+    expected?: string | undefined;
+    received?: string | undefined;
+    message?: ErrorMessage<InferIssue<TContext>> | undefined;
+    path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+    issues?: [BaseIssue<InferInput<TContext>>, ...BaseIssue<InferInput<TContext>>[]] | undefined;
+}
+/**
+ * Adds an issue to the dataset.
+ *
+ * @param context The issue context.
+ * @param label The issue label.
+ * @param dataset The input dataset.
+ * @param config The configuration.
+ * @param other The optional props.
+ *
+ * @internal
+ */
+export declare function _addIssue<const TContext extends Context>(context: TContext & {
+    expects?: string | null;
+    requirement?: unknown;
+    message?: ErrorMessage<Extract<InferIssue<TContext>, {
+        type: TContext['type'];
+    }>> | undefined;
+}, label: string, dataset: UnknownDataset | OutputDataset<unknown, BaseIssue<unknown>>, config: Config<InferIssue<TContext>>, other?: Other<TContext>): void;
+export {};