@alint-js/plugin-simplicity 0.0.28 → 0.0.30

package/dist/index.d.mts

@@ -1,6 +1,294 @@
-import { RuleContext, SourceLocation, SourceRange } from "@alint-js/core";
-import { AgentTool } from "@alint-js/core/agent";
-import { InferOutput } from "valibot";
+//#region ../plugin/dist/index.d.mts
+//#region ../core/dist/types-DSvXUVZ7.d.mts
+//#region src/core/source/types.d.ts
+type ClassTarget = SourceTargetOfKind<'class'>;
+type FileTarget = SourceTargetOfKind<'file'>;
+type FunctionTarget = SourceTargetOfKind<'function'>;
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface ProcessedSource {
+  identity: string;
+  language?: string;
+  origin?: ProcessedSourceOrigin;
+  path: string;
+  text: string;
+}
+interface ProcessedSourceOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface ProcessorContext {
+  cwd: string;
+  options: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface ProcessorPostprocessContext extends ProcessorContext {
+  file: SourceFile;
+  processedSources: ProcessedSource[];
+}
+interface SourceFile {
+  language: string;
+  lines: string[];
+  path: string;
+  text: string;
+}
+interface SourceLocation {
+  end: SourcePosition;
+  start: SourcePosition;
+}
+interface SourcePosition {
+  column: number;
+  line: number;
+}
+interface SourceRange {
+  end: number;
+  start: number;
+}
+interface SourceRuntime {
+  getText: (target: SourceFile | SourceTarget) => string;
+  readFile: (filePath: string) => Promise<SourceFile>;
+  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
+  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
+}
+interface SourceTarget {
+  file: SourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: Record<string, unknown>;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+  text: string;
+}
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+type SourceTargetOfKind<Kind extends SourceTargetKind> = Omit<SourceTarget, 'kind'> & {
+  kind: Kind;
+};
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+//#endregion
+//#region ../core/dist/types-CR_Grd6q.d.mts
+//#region src/config/types.d.ts
+type ModelSize = 'large' | 'medium' | 'small';
+interface RunnerCacheConfig {
+  enabled?: boolean;
+  location?: string;
+}
+interface RunnerConfig {
+  /** Retries after the initial attempt for replay-safe agent failures. @default 2 */
+  agentRetries?: number;
+  cache?: boolean | RunnerCacheConfig;
+  ruleConcurrency?: number;
+  stats?: boolean | RunnerStatsConfig;
+  timeoutMs?: number;
+}
+interface RunnerStatsConfig {
+  enabled?: boolean;
+  location?: string;
+  retentionMonths?: number;
+}
+//#endregion
+//#region src/models/types.d.ts
+interface ModelRequirement {
+  capabilities?: string[];
+  minContextWindow?: number;
+  params?: Record<string, unknown>;
+  size?: ModelSize;
+}
+interface ResolvedModel {
+  aliases: string[];
+  capabilities: string[];
+  contextWindow?: number;
+  id: string;
+  name: string;
+  params: Record<string, unknown>;
+  provider: ResolvedProvider;
+  size?: ModelSize;
+}
+interface ResolvedProvider {
+  endpoint: string;
+  headers: Record<string, string>;
+  id: string;
+  type: 'openai-compatible';
+}
+//#endregion
+//#region src/agent/types.d.ts
+type AgentAdapter = (request: AgentRequest) => Promise<AgentResult>;
+interface AgentRequest {
+  instructions: string;
+  model: ResolvedModel;
+  prompt: string;
+  signal?: AbortSignal;
+  tools: AgentTool$1[];
+}
+interface AgentResult {
+  answer: string;
+  usage?: AgentUsage;
+}
+/** Agent-agnostic tool definition. Each adapter translates it to its framework's tool format. */
+interface AgentTool$1 {
+  description: string;
+  execute: (input: unknown) => Promise<unknown> | unknown;
+  name: string;
+  parameters: Record<string, unknown>;
+}
+interface AgentUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+type AlintConfigExtends = AlintConfigInput | string;
+type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
+interface AlintConfigItem {
+  agent?: AgentAdapter;
+  basePath?: string;
+  directories?: readonly (readonly string[] | string)[];
+  extends?: readonly AlintConfigExtends[];
+  files?: readonly (readonly string[] | string)[];
+  ignore?: IgnoreConfig;
+  ignores?: readonly string[];
+  language?: string;
+  languageOptions?: Record<string, unknown>;
+  linterOptions?: AlintLinterOptions;
+  name?: string;
+  plugins?: Record<string, PluginDefinition>;
+  processor?: ProcessorDefinition | string;
+  rules?: Record<string, RuleConfigEntry>;
+  runner?: RunnerConfig;
+  settings?: Record<string, unknown>;
+}
+interface AlintLinterOptions {
+  noInlineConfig?: boolean;
+  reportUnusedDisableDirectives?: RuleSeverity;
+}
+type Awaitable<T> = Promise<T> | T;
+interface DiagnosticDescriptor {
+  evidence?: unknown;
+  filePath?: string;
+  loc?: DiagnosticLocation;
+  message: string;
+}
+interface DiagnosticLocation {
+  end?: {
+    column: number;
+    line: number;
+  };
+  start: {
+    column: number;
+    line: number;
+  };
+}
+interface DirectoryTarget {
+  kind: 'directory';
+  path: string;
+}
+interface IgnoreConfig {
+  gitignore?: boolean;
+}
+interface LanguageDefinition {
+  extensions?: readonly string[];
+  extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
+  name: string;
+}
+interface PluginDefinition {
+  configs?: Record<string, AlintConfigInput>;
+  languages?: Record<string, LanguageDefinition>;
+  processors?: Record<string, ProcessorDefinition>;
+  rules?: Record<string, RuleDefinition>;
+}
+interface ProcessorDefinition {
+  postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
+  preprocess: (file: SourceFile, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
+}
+interface ProjectTarget {
+  files: SourceFile[];
+  kind: 'project';
+  root: string;
+  targets: SourceTarget[];
+}
+type RuleCacheConfig = boolean | {
+  level?: 'target';
+};
+type RuleConfigEntry = [RuleSeverity] | RuleSeverity;
+interface RuleContext {
+  agent?: AgentAdapter;
+  cwd: string;
+  id: string;
+  localId: string;
+  logger: {
+    debug: (...args: unknown[]) => void;
+  };
+  metering: {
+    recordUsage: (usage: RuleInferenceUsageRecord) => void;
+  };
+  model: (selector?: ModelRequirement | string) => Promise<ResolvedModel>;
+  outputLanguage?: string;
+  report: (diagnostic: DiagnosticDescriptor) => void;
+  settings: Record<string, unknown>;
+  /**
+   * Cancels the run. Forward it to anything long-running a rule starts, so cancelling stops
+   * the work instead of letting it finish and bill.
+   *
+   * `ctx.agent` already injects it, and `generateStructured` accepts it as `signal`.
+   */
+  signal?: AbortSignal;
+  src: SourceRuntime;
+}
+interface RuleDefinition {
+  cache?: RuleCacheConfig;
+  /** Additional stable rule inputs, such as imported prompts, that invalidate cached results when changed. */
+  cacheKey?: unknown;
+  create: (context: RuleContext) => RuleHandlers;
+  model?: ModelRequirement;
+}
+type RuleHandlers = RuleSpecializedHandlers | RuleWithHandler;
+interface RuleInferenceUsageRecord {
+  filePath?: string;
+  inputTokens?: number;
+  metadata?: unknown;
+  modelId: string;
+  outputTokens?: number;
+  providerId: string;
+  ruleId?: string;
+  totalTokens?: number;
+}
+type RuleSeverity = 'error' | 'off' | 'warn';
+interface RuleSpecializedHandlers {
+  onTargetClass?: (target: ClassTarget) => Awaitable<void>;
+  onTargetDirectory?: (target: DirectoryTarget) => Awaitable<void>;
+  onTargetFile?: (target: FileTarget) => Awaitable<void>;
+  onTargetFunction?: (target: FunctionTarget) => Awaitable<void>;
+  onTargetProject?: (target: ProjectTarget) => Awaitable<void>;
+  onTargetWith?: never;
+}
+interface RuleWithHandler {
+  onTargetClass?: never;
+  onTargetDirectory?: never;
+  onTargetFile?: never;
+  onTargetFunction?: never;
+  onTargetProject?: never;
+  onTargetWith: (target: Target) => Awaitable<void>;
+}
+type Target = DirectoryTarget | ProjectTarget | SourceTarget;
+//#endregion
 //#region src/extract/types.d.ts
 interface CallSite {
   /** The last segment only: `a.b.helper()` and `helper()` both yield `helper`. */
@@ -56,6 +344,15 @@ declare function tokenize(text: string, commentRanges: readonly SourceRange[], i
 /** Shared token fraction of the larger bag. Ranks candidates, decides nothing. */
 declare function tokenOverlap(left: readonly string[], right: readonly string[]): number;
 //#endregion
+//#region ../core/dist/types-CR_Grd6q.d.mts
+/** Agent-agnostic tool definition. Each adapter translates it to its framework's tool format. */
+interface AgentTool {
+  description: string;
+  execute: (input: unknown) => Promise<unknown> | unknown;
+  name: string;
+  parameters: Record<string, unknown>;
+}
+//#endregion
 //#region src/rules/no-duplicated-helper/tools.d.ts
 interface AgentFinding {
   helperId: string;
@@ -149,18 +446,1615 @@ declare function buildDuplicatedHelperPrompt(options: {
  * Identical bodies and renamed-only copies are settled by AST fingerprints, with no model. What
  * a fingerprint cannot settle goes to an agent holding the whole index as tools.
  */
-declare const duplicatedHelperRule: import("@alint-js/core").RuleDefinition;
+declare const duplicatedHelperRule: RuleDefinition;
 //#endregion
 //#region src/rules/no-needless-helper/prompt.d.ts
 declare const needlessHelperPrompt: string;
 declare function buildNeedlessHelperPrompt(helpers: readonly IndexedHelper[]): string;
 //#endregion
+//#region ../../node_modules/.pnpm/valibot@1.4.2_typescript@6.0.3/node_modules/valibot/dist/index.d.mts
+//#endregion
+//#region src/methods/fallback/fallback.d.ts
+/**
+ * Fallback type.
+ */
+type Fallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> = MaybeDeepReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybeDeepReadonly<InferOutput<TSchema>>);
+/**
+ * Schema with fallback type.
+ */
+type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback$1 extends Fallback<TSchema>> = TSchema & {
+  /**
+   * The fallback value.
+   */
+  readonly fallback: TFallback$1;
+};
+//#endregion
+//#region src/methods/fallback/fallbackAsync.d.ts
+/**
+ * Fallback async type.
+ */
+type FallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = MaybeDeepReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybePromise<MaybeDeepReadonly<InferOutput<TSchema>>>);
+/**
+ * Schema with fallback async type.
+ */
+type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback$1 extends FallbackAsync<TSchema>> = Omit<TSchema, "async" | "~standard" | "~run"> & {
+  /**
+   * The fallback value.
+   */
+  readonly fallback: TFallback$1;
+  /**
+   * Whether it's async.
+   */
+  readonly async: true;
+  /**
+   * The Standard Schema properties.
+   *
+   * @internal
+   */
+  readonly "~standard": StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
+  /**
+   * 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<InferOutput<TSchema>, InferIssue<TSchema>>>;
+};
+//#endregion
+//#region src/methods/pipe/pipe.d.ts
+/**
+ * Schema with pipe type.
+ */
+type SchemaWithPipe<TPipe$1 extends readonly [BaseSchema<unknown, unknown, BaseIssue<unknown>>, ...PipeItem<any, unknown, BaseIssue<unknown>>[]]> = Omit<FirstTupleItem<TPipe$1>, "pipe" | "~standard" | "~run" | "~types"> & {
+  /**
+   * The pipe items.
+   */
+  readonly pipe: TPipe$1;
+  /**
+   * The Standard Schema properties.
+   *
+   * @internal
+   */
+  readonly "~standard": StandardProps<InferInput<FirstTupleItem<TPipe$1>>, InferOutput<LastTupleItem<TPipe$1>>>;
+  /**
+   * 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<InferOutput<LastTupleItem<TPipe$1>>, InferIssue<TPipe$1[number]>>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: InferInput<FirstTupleItem<TPipe$1>>;
+    readonly output: InferOutput<LastTupleItem<TPipe$1>>;
+    readonly issue: InferIssue<TPipe$1[number]>;
+  } | undefined;
+};
+//#endregion
+//#region src/types/metadata.d.ts
+/**
+ * Base metadata interface.
+ */
+interface BaseMetadata<TInput$1> {
+  /**
+   * The object kind.
+   */
+  readonly kind: "metadata";
+  /**
+   * The metadata type.
+   */
+  readonly type: string;
+  /**
+   * The metadata reference.
+   */
+  readonly reference: (...args: any[]) => BaseMetadata<any>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TInput$1;
+    readonly issue: never;
+  } | undefined;
+}
+//#endregion
+//#region src/types/dataset.d.ts
+/**
+ * Unknown dataset interface.
+ */
+interface UnknownDataset {
+  /**
+   * Whether is's typed.
+   */
+  typed?: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Success dataset interface.
+ */
+interface SuccessDataset<TValue$1> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue$1;
+  /**
+   * The dataset issues.
+   */
+  issues?: undefined;
+}
+/**
+ * Partial dataset interface.
+ */
+interface PartialDataset<TValue$1, TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: true;
+  /**
+   * The dataset value.
+   */
+  value: TValue$1;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Failure dataset interface.
+ */
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
+  /**
+   * Whether is's typed.
+   */
+  typed: false;
+  /**
+   * The dataset value.
+   */
+  value: unknown;
+  /**
+   * The dataset issues.
+   */
+  issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Output dataset type.
+ */
+type OutputDataset<TValue$1, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue$1> | PartialDataset<TValue$1, TIssue> | FailureDataset<TIssue>;
+//#endregion
+//#region src/types/standard.d.ts
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardProps<TInput$1, TOutput$1> {
+  /**
+   * The version number of the standard.
+   */
+  readonly version: 1;
+  /**
+   * The vendor name of the schema library.
+   */
+  readonly vendor: "valibot";
+  /**
+   * Validates unknown input values.
+   */
+  readonly validate: (value: unknown) => StandardResult<TOutput$1> | Promise<StandardResult<TOutput$1>>;
+  /**
+   * Inferred types associated with the schema.
+   */
+  readonly types?: StandardTypes<TInput$1, TOutput$1> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardResult<TOutput$1> = StandardSuccessResult<TOutput$1> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSuccessResult<TOutput$1> {
+  /**
+   * The typed output value.
+   */
+  readonly value: TOutput$1;
+  /**
+   * The non-existent issues.
+   */
+  readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardFailureResult {
+  /**
+   * The issues of failed validation.
+   */
+  readonly issues: readonly StandardIssue[];
+}
+/**
+ * The issue interface of the failure output.
+ */
+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.
+ */
+interface StandardPathItem {
+  /**
+   * The key of the path item.
+   */
+  readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardTypes<TInput$1, TOutput$1> {
+  /**
+   * The input type of the schema.
+   */
+  readonly input: TInput$1;
+  /**
+   * The output type of the schema.
+   */
+  readonly output: TOutput$1;
+}
+//#endregion
+//#region src/types/schema.d.ts
+/**
+ * Base schema interface.
+ */
+interface BaseSchema<TInput$1, TOutput$1, 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$1, TOutput$1>;
+  /**
+   * 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$1, TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base schema async interface.
+ */
+interface BaseSchemaAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput$1, TOutput$1, 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$1, TIssue>>;
+}
+//#endregion
+//#region src/types/transformation.d.ts
+/**
+ * Base transformation interface.
+ */
+interface BaseTransformation<TInput$1, TOutput$1, 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$1>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base transformation async interface.
+ */
+interface BaseTransformationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput$1, TOutput$1, 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$1>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
+}
+//#endregion
+//#region src/types/validation.d.ts
+/**
+ * Base validation interface.
+ */
+interface BaseValidation<TInput$1, TOutput$1, 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$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>;
+  /**
+   * The input, output and issue type.
+   *
+   * @internal
+   */
+  readonly "~types"?: {
+    readonly input: TInput$1;
+    readonly output: TOutput$1;
+    readonly issue: TIssue;
+  } | undefined;
+}
+/**
+ * Base validation async interface.
+ */
+interface BaseValidationAsync<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput$1, TOutput$1, 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$1, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput$1, BaseIssue<unknown> | TIssue>>;
+}
+//#endregion
+//#region src/types/infer.d.ts
+/**
+ * Infer input type.
+ */
+type InferInput<TItem$1 extends 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>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["input"];
+/**
+ * Infer output type.
+ */
+type InferOutput<TItem$1 extends 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>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["output"];
+/**
+ * Infer issue type.
+ */
+type InferIssue<TItem$1 extends 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>> | BaseMetadata<any>> = NonNullable<TItem$1["~types"]>["issue"];
+/**
+ * Constructs a type that is maybe readonly.
+ */
+type MaybeReadonly<TValue$1> = TValue$1 | Readonly<TValue$1>;
+/**
+ * Constructs a type that is deeply readonly.
+ */
+type DeepReadonly<TValue$1> = TValue$1 extends Record<string, unknown> | readonly unknown[] ? { readonly [TKey in keyof TValue$1]: DeepReadonly<TValue$1[TKey]>; } : TValue$1;
+/**
+ * Constructs a type that is maybe deeply readonly.
+ */
+type MaybeDeepReadonly<TValue$1> = TValue$1 | DeepReadonly<TValue$1>;
+/**
+ * Constructs a type that is maybe a promise.
+ */
+type MaybePromise<TValue$1> = TValue$1 | Promise<TValue$1>;
+/**
+ * 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.
+ */
+type Prettify<TObject> = { [TKey in keyof TObject]: TObject[TKey]; } & {};
+/**
+ * Marks specific keys as optional.
+ */
+type MarkOptional<TObject, TKeys extends keyof TObject> = { [TKey in keyof TObject]?: unknown; } & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Extracts first tuple item.
+ */
+type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [unknown, ...infer TRest] ? TRest["length"] : never];
+//#endregion
+//#region src/types/other.d.ts
+/**
+ * Error message type.
+ */
+type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
+/**
+ * Default type.
+ */
+type Default<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput$1 extends null | undefined> = MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped$1>>) => MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1>) | undefined;
+/**
+ * Default async type.
+ */
+type DefaultAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput$1 extends null | undefined> = MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped$1>>) => MaybePromise<MaybeDeepReadonly<InferInput<TWrapped$1> | TInput$1>>) | undefined;
+/**
+ * Default value type.
+ */
+type DefaultValue<TDefault extends Default<BaseSchema<unknown, unknown, BaseIssue<unknown>>, null | undefined> | DefaultAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, null | undefined>> = TDefault extends DefaultAsync<infer TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TInput> ? TDefault extends ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeDeepReadonly<InferInput<TWrapped> | TInput>>) ? Awaited<ReturnType<TDefault>> : TDefault : never;
+//#endregion
+//#region src/types/object.d.ts
+/**
+ * Optional entry schema type.
+ */
+type OptionalEntrySchema = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Optional entry schema async type.
+ */
+type OptionalEntrySchemaAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Object entries interface.
+ */
+interface ObjectEntries {
+  [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema;
+}
+/**
+ * Object entries async interface.
+ */
+interface ObjectEntriesAsync {
+  [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema | OptionalEntrySchemaAsync;
+}
+/**
+ * Infer entries input type.
+ */
+type InferEntriesInput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { -readonly [TKey in keyof TEntries$1]: InferInput<TEntries$1[TKey]>; };
+/**
+ * Infer entries output type.
+ */
+type InferEntriesOutput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { -readonly [TKey in keyof TEntries$1]: InferOutput<TEntries$1[TKey]>; };
+/**
+ * Optional input keys type.
+ */
+type OptionalInputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? TKey : never; }[keyof TEntries$1];
+/**
+ * Optional output keys type.
+ */
+type OptionalOutputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? undefined extends TEntries$1[TKey]["default"] ? TKey : never : never; }[keyof TEntries$1];
+/**
+ * Input with question marks type.
+ */
+type InputWithQuestionMarks<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries$1>> = MarkOptional<TObject, OptionalInputKeys<TEntries$1>>;
+/**
+ * Output with question marks type.
+ */
+type OutputWithQuestionMarks<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesOutput<TEntries$1>> = MarkOptional<TObject, OptionalOutputKeys<TEntries$1>>;
+/**
+ * Readonly output keys type.
+ */
+type ReadonlyOutputKeys<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = { [TKey in keyof TEntries$1]: TEntries$1[TKey] extends {
+  readonly pipe: readonly unknown[];
+} ? ReadonlyAction<any> extends TEntries$1[TKey]["pipe"][number] ? TKey : never : never; }[keyof TEntries$1];
+/**
+ * Output with readonly type.
+ */
+type OutputWithReadonly<TEntries$1 extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries$1, InferEntriesOutput<TEntries$1>>> = ReadonlyOutputKeys<TEntries$1> extends never ? TObject : Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries$1>>>;
+/**
+ * Infer object input type.
+ */
+type InferObjectInput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries$1, InferEntriesInput<TEntries$1>>>;
+/**
+ * Infer object output type.
+ */
+type InferObjectOutput<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries$1, OutputWithQuestionMarks<TEntries$1, InferEntriesOutput<TEntries$1>>>>;
+/**
+ * Infer object issue type.
+ */
+type InferObjectIssue<TEntries$1 extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries$1[keyof TEntries$1]>;
+//#endregion
+//#region src/types/issue.d.ts
+/**
+ * Array path item interface.
+ */
+interface ArrayPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "array";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "value";
+  /**
+   * The path item input.
+   */
+  readonly input: MaybeReadonly<unknown[]>;
+  /**
+   * The path item key.
+   */
+  readonly key: number;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Map path item interface.
+ */
+interface MapPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "map";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Map<unknown, unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: unknown;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Object path item interface.
+ */
+interface ObjectPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "object";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Record<string, unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: string;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Set path item interface.
+ */
+interface SetPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "set";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "value";
+  /**
+   * The path item input.
+   */
+  readonly input: Set<unknown>;
+  /**
+   * The path item key.
+   */
+  readonly key: null;
+  /**
+   * The path item key.
+   */
+  readonly value: unknown;
+}
+/**
+ * Unknown path item interface.
+ */
+interface UnknownPathItem {
+  /**
+   * The path item type.
+   */
+  readonly type: "unknown";
+  /**
+   * The path item origin.
+   */
+  readonly origin: "key" | "value";
+  /**
+   * The path item input.
+   */
+  readonly input: unknown;
+  /**
+   * The path item key.
+   */
+  readonly key: unknown;
+  /**
+   * The path item value.
+   */
+  readonly value: unknown;
+}
+/**
+ * Issue path item type.
+ */
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue interface.
+ */
+interface BaseIssue<TInput$1> extends Config<BaseIssue<TInput$1>> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema" | "validation" | "transformation";
+  /**
+   * The issue type.
+   */
+  readonly type: string;
+  /**
+   * The raw input data.
+   */
+  readonly input: TInput$1;
+  /**
+   * The expected property.
+   */
+  readonly expected: string | null;
+  /**
+   * The received property.
+   */
+  readonly received: string;
+  /**
+   * The error message.
+   */
+  readonly message: string;
+  /**
+   * The input requirement.
+   */
+  readonly requirement?: unknown | undefined;
+  /**
+   * The issue path.
+   */
+  readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+  /**
+   * The sub issues.
+   */
+  readonly issues?: [BaseIssue<TInput$1>, ...BaseIssue<TInput$1>[]] | undefined;
+}
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * Config interface.
+ */
+interface Config<TIssue extends BaseIssue<unknown>> {
+  /**
+   * The selected language.
+   */
+  readonly lang?: string | undefined;
+  /**
+   * The error message.
+   */
+  readonly message?: ErrorMessage<TIssue> | undefined;
+  /**
+   * Whether it should be aborted early.
+   */
+  readonly abortEarly?: boolean | undefined;
+  /**
+   * Whether a pipe should be aborted early.
+   */
+  readonly abortPipeEarly?: boolean | undefined;
+}
+//#endregion
+//#region src/types/pipe.d.ts
+/**
+ * Pipe action type.
+ */
+type PipeAction<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> = BaseValidation<TInput$1, TOutput$1, TIssue> | BaseTransformation<TInput$1, TOutput$1, TIssue> | BaseMetadata<TInput$1>;
+/**
+ * Pipe item type.
+ */
+type PipeItem<TInput$1, TOutput$1, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput$1, TOutput$1, TIssue> | PipeAction<TInput$1, TOutput$1, TIssue>;
+//#endregion
+//#region src/schemas/array/types.d.ts
+/**
+ * Array issue interface.
+ */
+interface ArrayIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The issue type.
+   */
+  readonly type: "array";
+  /**
+   * The expected property.
+   */
+  readonly expected: "Array";
+}
+//#endregion
+//#region src/schemas/array/array.d.ts
+/**
+ * Array schema interface.
+ */
+interface ArraySchema<TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem$1>[], InferOutput<TItem$1>[], ArrayIssue | InferIssue<TItem$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "array";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof array;
+  /**
+   * The expected property.
+   */
+  readonly expects: "Array";
+  /**
+   * The array item schema.
+   */
+  readonly item: TItem$1;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem$1): ArraySchema<TItem$1, undefined>;
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ * @param message The error message.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem$1, message: TMessage): ArraySchema<TItem$1, TMessage>;
+//#endregion
+//#region src/schemas/boolean/boolean.d.ts
+/**
+ * Boolean issue interface.
+ */
+interface BooleanIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The issue type.
+   */
+  readonly type: "boolean";
+  /**
+   * The expected property.
+   */
+  readonly expected: "boolean";
+}
+/**
+ * Boolean schema interface.
+ */
+interface BooleanSchema<TMessage extends ErrorMessage<BooleanIssue> | undefined> extends BaseSchema<boolean, boolean, BooleanIssue> {
+  /**
+   * The schema type.
+   */
+  readonly type: "boolean";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof boolean;
+  /**
+   * The expected property.
+   */
+  readonly expects: "boolean";
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a boolean schema.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean(): BooleanSchema<undefined>;
+/**
+ * Creates a boolean schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean<const TMessage extends ErrorMessage<BooleanIssue> | undefined>(message: TMessage): BooleanSchema<TMessage>;
+//#endregion
+//#region src/schemas/exactOptional/exactOptional.d.ts
+/**
+ * Exact optional schema interface.
+ */
+interface ExactOptionalSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, never>> extends BaseSchema<InferInput<TWrapped$1>, InferOutput<TWrapped$1>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "exact_optional";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof exactOptional;
+  /**
+   * The expected property.
+   */
+  readonly expects: TWrapped$1["expects"];
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): ExactOptionalSchema<TWrapped$1, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, never>>(wrapped: TWrapped$1, default_: TDefault): ExactOptionalSchema<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/exactOptional/exactOptionalAsync.d.ts
+/**
+ * Exact optional schema async interface.
+ */
+interface ExactOptionalSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, never>> extends BaseSchemaAsync<InferInput<TWrapped$1>, InferOutput<TWrapped$1>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "exact_optional";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof exactOptional | typeof exactOptionalAsync;
+  /**
+   * The expected property.
+   */
+  readonly expects: TWrapped$1["expects"];
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): ExactOptionalSchemaAsync<TWrapped$1, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, never>>(wrapped: TWrapped$1, default_: TDefault): ExactOptionalSchemaAsync<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/nullish/types.d.ts
+/**
+ * Infer nullish output type.
+ */
+type InferNullishOutput<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, null | undefined>> = undefined extends TDefault ? InferOutput<TWrapped$1> | null | undefined : InferOutput<TWrapped$1> | Extract<DefaultValue<TDefault>, null | undefined>;
+//#endregion
+//#region src/schemas/nullish/nullish.d.ts
+/**
+ * Nullish schema interface.
+ */
+interface NullishSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, null | undefined>> extends BaseSchema<InferInput<TWrapped$1> | null | undefined, InferNullishOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "nullish";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof nullish;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped$1["expects"]} | null | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullish<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): NullishSchema<TWrapped$1, undefined>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullish<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, null | undefined>>(wrapped: TWrapped$1, default_: TDefault): NullishSchema<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/nullish/nullishAsync.d.ts
+/**
+ * Nullish schema async interface.
+ */
+interface NullishSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, null | undefined>> extends BaseSchemaAsync<InferInput<TWrapped$1> | null | undefined, InferNullishOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "nullish";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof nullish | typeof nullishAsync;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped$1["expects"]} | null | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullishAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): NullishSchemaAsync<TWrapped$1, undefined>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullishAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, null | undefined>>(wrapped: TWrapped$1, default_: TDefault): NullishSchemaAsync<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/number/number.d.ts
+/**
+ * Number issue interface.
+ */
+interface NumberIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The issue type.
+   */
+  readonly type: "number";
+  /**
+   * The expected property.
+   */
+  readonly expected: "number";
+}
+/**
+ * Number schema interface.
+ */
+interface NumberSchema<TMessage extends ErrorMessage<NumberIssue> | undefined> extends BaseSchema<number, number, NumberIssue> {
+  /**
+   * The schema type.
+   */
+  readonly type: "number";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof number;
+  /**
+   * The expected property.
+   */
+  readonly expects: "number";
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a number schema.
+ *
+ * @returns A number schema.
+ */
+declare function number(): NumberSchema<undefined>;
+/**
+ * Creates a number schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A number schema.
+ */
+declare function number<const TMessage extends ErrorMessage<NumberIssue> | undefined>(message: TMessage): NumberSchema<TMessage>;
+//#endregion
+//#region src/schemas/object/types.d.ts
+/**
+ * Object issue interface.
+ */
+interface ObjectIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The issue type.
+   */
+  readonly type: "object";
+  /**
+   * The expected property.
+   */
+  readonly expected: "Object" | `"${string}"`;
+}
+//#endregion
+//#region src/schemas/object/object.d.ts
+/**
+ * Object schema interface.
+ */
+interface ObjectSchema<TEntries$1 extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries$1>, InferObjectOutput<TEntries$1>, ObjectIssue | InferObjectIssue<TEntries$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "object";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof object;
+  /**
+   * The expected property.
+   */
+  readonly expects: "Object";
+  /**
+   * The entries schema.
+   */
+  readonly entries: TEntries$1;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries$1 extends ObjectEntries>(entries: TEntries$1): ObjectSchema<TEntries$1, undefined>;
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ * @param message The error message.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries$1 extends ObjectEntries, const TMessage extends ErrorMessage<ObjectIssue> | undefined>(entries: TEntries$1, message: TMessage): ObjectSchema<TEntries$1, TMessage>;
+//#endregion
+//#region src/schemas/optional/types.d.ts
+/**
+ * Infer optional output type.
+ */
+type InferOptionalOutput<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, undefined>> = undefined extends TDefault ? InferOutput<TWrapped$1> | undefined : InferOutput<TWrapped$1> | Extract<DefaultValue<TDefault>, undefined>;
+//#endregion
+//#region src/schemas/optional/optional.d.ts
+/**
+ * Optional schema interface.
+ */
+interface OptionalSchema<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped$1, undefined>> extends BaseSchema<InferInput<TWrapped$1> | undefined, InferOptionalOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "optional";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof optional;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped$1["expects"]} | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): OptionalSchema<TWrapped$1, undefined>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
+ */
+declare function optional<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped$1, undefined>>(wrapped: TWrapped$1, default_: TDefault): OptionalSchema<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/optional/optionalAsync.d.ts
+/**
+ * Optional schema async interface.
+ */
+interface OptionalSchemaAsync<TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped$1, undefined>> extends BaseSchemaAsync<InferInput<TWrapped$1> | undefined, InferOptionalOutput<TWrapped$1, TDefault>, InferIssue<TWrapped$1>> {
+  /**
+   * The schema type.
+   */
+  readonly type: "optional";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof optional | typeof optionalAsync;
+  /**
+   * The expected property.
+   */
+  readonly expects: `(${TWrapped$1["expects"]} | undefined)`;
+  /**
+   * The wrapped schema.
+   */
+  readonly wrapped: TWrapped$1;
+  /**
+   * The default value.
+   */
+  readonly default: TDefault;
+}
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped$1): OptionalSchemaAsync<TWrapped$1, undefined>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped$1 extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped$1, undefined>>(wrapped: TWrapped$1, default_: TDefault): OptionalSchemaAsync<TWrapped$1, TDefault>;
+//#endregion
+//#region src/schemas/string/string.d.ts
+/**
+ * String issue interface.
+ */
+interface StringIssue extends BaseIssue<unknown> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "schema";
+  /**
+   * The issue type.
+   */
+  readonly type: "string";
+  /**
+   * The expected property.
+   */
+  readonly expected: "string";
+}
+/**
+ * String schema interface.
+ */
+interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
+  /**
+   * The schema type.
+   */
+  readonly type: "string";
+  /**
+   * The schema reference.
+   */
+  readonly reference: typeof string;
+  /**
+   * The expected property.
+   */
+  readonly expects: "string";
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a string schema.
+ *
+ * @returns A string schema.
+ */
+declare function string(): StringSchema<undefined>;
+/**
+ * Creates a string schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A string schema.
+ */
+declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
+/**
+ * Value input type.
+ */
+type ValueInput = string | number | bigint | boolean | Date;
+//#endregion
+//#region src/actions/description/description.d.ts
+/**
+ * Description action interface.
+ */
+interface DescriptionAction<TInput$1, TDescription extends string> extends BaseMetadata<TInput$1> {
+  /**
+   * The action type.
+   */
+  readonly type: "description";
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof description;
+  /**
+   * The description text.
+   */
+  readonly description: TDescription;
+}
+/**
+ * Creates a description metadata action.
+ *
+ * @param description_ The description text.
+ *
+ * @returns A description action.
+ */
+declare function description<TInput$1, TDescription extends string>(description_: TDescription): DescriptionAction<TInput$1, TDescription>;
+//#endregion
+//#region src/actions/integer/integer.d.ts
+/**
+ * Integer issue interface.
+ */
+interface IntegerIssue<TInput$1 extends number> extends BaseIssue<TInput$1> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "validation";
+  /**
+   * The issue type.
+   */
+  readonly type: "integer";
+  /**
+   * The expected property.
+   */
+  readonly expected: null;
+  /**
+   * The received property.
+   */
+  readonly received: `${number}`;
+  /**
+   * The validation function.
+   */
+  readonly requirement: (input: number) => boolean;
+}
+/**
+ * Integer action interface.
+ */
+interface IntegerAction<TInput$1 extends number, TMessage extends ErrorMessage<IntegerIssue<TInput$1>> | undefined> extends BaseValidation<TInput$1, TInput$1, IntegerIssue<TInput$1>> {
+  /**
+   * The action type.
+   */
+  readonly type: "integer";
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof integer;
+  /**
+   * The expected property.
+   */
+  readonly expects: null;
+  /**
+   * The validation function.
+   */
+  readonly requirement: (input: number) => boolean;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates an [integer](https://en.wikipedia.org/wiki/Integer) validation action.
+ *
+ * @returns An integer action.
+ */
+declare function integer<TInput$1 extends number>(): IntegerAction<TInput$1, undefined>;
+/**
+ * Creates an [integer](https://en.wikipedia.org/wiki/Integer) validation action.
+ *
+ * @param message The error message.
+ *
+ * @returns An integer action.
+ */
+declare function integer<TInput$1 extends number, const TMessage extends ErrorMessage<IntegerIssue<TInput$1>> | undefined>(message: TMessage): IntegerAction<TInput$1, TMessage>;
+//#endregion
+//#region src/actions/minValue/minValue.d.ts
+/**
+ * Min value issue interface.
+ */
+interface MinValueIssue<TInput$1 extends ValueInput, TRequirement extends ValueInput> extends BaseIssue<TInput$1> {
+  /**
+   * The issue kind.
+   */
+  readonly kind: "validation";
+  /**
+   * The issue type.
+   */
+  readonly type: "min_value";
+  /**
+   * The expected property.
+   */
+  readonly expected: `>=${string}`;
+  /**
+   * The minimum value.
+   */
+  readonly requirement: TRequirement;
+}
+/**
+ * Min value action interface.
+ */
+interface MinValueAction<TInput$1 extends ValueInput, TRequirement extends TInput$1, TMessage extends ErrorMessage<MinValueIssue<TInput$1, TRequirement>> | undefined> extends BaseValidation<TInput$1, TInput$1, MinValueIssue<TInput$1, TRequirement>> {
+  /**
+   * The action type.
+   */
+  readonly type: "min_value";
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof minValue;
+  /**
+   * The expected property.
+   */
+  readonly expects: `>=${string}`;
+  /**
+   * The minimum value.
+   */
+  readonly requirement: TRequirement;
+  /**
+   * The error message.
+   */
+  readonly message: TMessage;
+}
+/**
+ * Creates a min value validation action.
+ *
+ * @param requirement The minimum value.
+ *
+ * @returns A min value action.
+ */
+declare function minValue<TInput$1 extends ValueInput, const TRequirement extends TInput$1>(requirement: TRequirement): MinValueAction<TInput$1, TRequirement, undefined>;
+/**
+ * Creates a min value validation action.
+ *
+ * @param requirement The minimum value.
+ * @param message The error message.
+ *
+ * @returns A min value action.
+ */
+declare function minValue<TInput$1 extends ValueInput, const TRequirement extends TInput$1, const TMessage extends ErrorMessage<MinValueIssue<TInput$1, TRequirement>> | undefined>(requirement: TRequirement, message: TMessage): MinValueAction<TInput$1, TRequirement, TMessage>;
+//#endregion
+//#region src/actions/readonly/readonly.d.ts
+/**
+ * Readonly output type.
+ */
+type ReadonlyOutput<TInput$1> = TInput$1 extends Map<infer TKey, infer TValue> ? ReadonlyMap<TKey, TValue> : TInput$1 extends Set<infer TValue> ? ReadonlySet<TValue> : Readonly<TInput$1>;
+/**
+ * Readonly action interface.
+ */
+interface ReadonlyAction<TInput$1> extends BaseTransformation<TInput$1, ReadonlyOutput<TInput$1>, never> {
+  /**
+   * The action type.
+   */
+  readonly type: "readonly";
+  /**
+   * The action reference.
+   */
+  readonly reference: typeof readonly;
+}
+/**
+ * Creates a readonly transformation action.
+ *
+ * @returns A readonly action.
+ */
+declare function readonly<TInput$1>(): ReadonlyAction<TInput$1>;
+//#endregion
 //#region src/rules/no-needless-helper/rule.d.ts
-declare const needlessHelperResponseSchema: import("valibot").ObjectSchema<{
-  readonly findings: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
-    readonly helper: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").DescriptionAction<number, "The number shown beside the helper, exactly as given.">]>;
-    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "The helper's name, exactly as shown.">]>;
-    readonly reason: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "At most twelve words, naming what the body already says.">]>;
+declare const needlessHelperResponseSchema: ObjectSchema<{
+  readonly findings: ArraySchema<ObjectSchema<{
+    readonly helper: SchemaWithPipe<readonly [NumberSchema<undefined>, DescriptionAction<number, "The number shown beside the helper, exactly as given.">]>;
+    readonly name: SchemaWithPipe<readonly [StringSchema<undefined>, DescriptionAction<string, "The helper's name, exactly as shown.">]>;
+    readonly reason: SchemaWithPipe<readonly [StringSchema<undefined>, DescriptionAction<string, "At most twelve words, naming what the body already says.">]>;
   }, undefined>, undefined>;
 }, undefined>;
 /**
@@ -170,24 +2064,24 @@ declare const needlessHelperResponseSchema: import("valibot").ObjectSchema<{
  * should not exist. The deterministic half only finds candidates and gathers facts (usage
  * count, exported), which are given to the model rather than applied as filters.
  */
-declare const needlessHelperRule: import("@alint-js/core").RuleDefinition;
+declare const needlessHelperRule: RuleDefinition;
 //#endregion
 //#region src/rules/shared/settings.d.ts
-declare const settingsSchema: import("valibot").ObjectSchema<{
-  readonly cache: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, true>;
+declare const settingsSchema: ObjectSchema<{
+  readonly cache: OptionalSchema<BooleanSchema<undefined>, true>;
   /** Globs matched against the repository-relative file path. */
-  readonly ignores: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, readonly []>;
+  readonly ignores: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, readonly []>;
   /**
    * When false, no model is called: `no-duplicated-helper` still reports what a fingerprint settles,
    * `no-needless-helper` reports nothing.
    */
-  readonly judge: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, true>;
-  readonly maxLines: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, 10>;
-  readonly minTokens: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>]>, 5>;
+  readonly judge: OptionalSchema<BooleanSchema<undefined>, true>;
+  readonly maxLines: OptionalSchema<SchemaWithPipe<readonly [NumberSchema<undefined>, IntegerAction<number, undefined>, MinValueAction<number, 1, undefined>]>, 10>;
+  readonly minTokens: OptionalSchema<SchemaWithPipe<readonly [NumberSchema<undefined>, IntegerAction<number, undefined>, MinValueAction<number, 1, undefined>]>, 5>;
 }, undefined>;
 type SimplicitySettings = InferOutput<typeof settingsSchema>;
 //#endregion
 //#region src/index.d.ts
-declare const simplicityPlugin: import("@alint-js/core").PluginDefinition;
+declare const simplicityPlugin: PluginDefinition;
 //#endregion
 export { type AgentFinding, type CallSite, type DuplicateToolsOptions, type ExtractLanguage, type ExtractedFunction, type IndexedHelper, type RepoIndex, type RepoIndexOptions, type ReviewCache, type SimplicitySettings, type SourceExtract, alphaFingerprint, buildDuplicatedHelperPrompt, buildNeedlessHelperPrompt, createDuplicateTools, simplicityPlugin as default, simplicityPlugin, duplicatedHelperInstructions, duplicatedHelperRule, exactFingerprint, extractSource, helpersIn, needlessHelperPrompt, needlessHelperResponseSchema, needlessHelperRule, normalizedBody, repoIndexFor, resolveExtractLanguage, reviewCacheFor, tokenOverlap, tokenize, twinsOf };