@clementine-solutions/jane-io 1.0.0 → 1.0.1

package/dist/core/common/policy.d.ts

@@ -0,0 +1,170 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Common | Policy
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Core types and helpers for defining, normalizing, and
+ *                  resolving policies that guide how Jane interprets events
+ *                  across all pipeline stages.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode, EventKind, FieldPath, Policy, PolicyContext, PolicyOverrides, PipelineResult, PipelineMetadata, BoundaryDecideConfig } from '../shapes';
+import type { PolicyInput } from '../shapes/policy';
+/**
+ * Raises an event’s severity by the given number of levels.
+ *
+ * Escalation moves the severity index upward and clamps it to the valid
+ * range. This helper is used by policy transforms to harden events without
+ * altering their underlying meaning or code.
+ */
+export declare function applyEscalate(kind: EventKind, levels: number): EventKind;
+/**
+ * Lowers an event’s severity by the given number of levels.
+ *
+ * Override moves the severity index downward and clamps it to the valid
+ * range. This helper is used by policy transforms to soften events without
+ * changing their underlying meaning or code.
+ */
+export declare function applyOverride(kind: EventKind, levels: number): EventKind;
+/**
+ * Clamps a severity index to the valid range.
+ *
+ * Severity levels are stored as an ordered list. This helper ensures that
+ * arithmetic on the index—such as escalation or override—never produces an
+ * out‑of‑bounds value. No interpretation occurs here; it simply enforces the
+ * valid numeric range.
+ */
+export declare function clampSeverityIndex(i: number): number;
+/**
+ * Compiles a user‑supplied severity map into override/escalation deltas.
+ *
+ * Each entry expresses a desired target severity for an event code. This
+ * helper compares the target against the baseline severity (“error”) and
+ * converts the difference into numeric levels suitable for the override and
+ * escalate policy transforms.
+ *
+ * Negative deltas become override levels; positive deltas become escalation
+ * levels. No interpretation occurs here—this function only computes the
+ * distance between severities.
+ */
+export declare function compileSeverityMap(severity: Readonly<Partial<Record<EventCode, EventKind>>>): {
+    override: Readonly<Partial<Record<EventCode, number>>>;
+    escalate: Readonly<Partial<Record<EventCode, number>>>;
+};
+/**
+ * Creates a `decide`‑phase event.
+ *
+ * Decision events are emitted after validation when policy logic evaluates
+ * severity, overrides, escalation, and boundary rules. This helper ensures
+ * all decision events share a consistent shape and metadata.
+ */
+export declare const decideEvent: (kind: EventKind, code: EventCode, path: FieldPath, message?: string, userMessage?: string, meta?: Record<string, unknown>) => import("../shapes").JaneEvent;
+/**
+ * The baseline policy used when no user configuration is provided.
+ *
+ * Moderate mode applies no automatic rejects, reviews, or severity transforms.
+ * Scan and analysis features are disabled, and no structural exceptions are
+ * granted. This preset defines Jane’s neutral, predictable behavior and serves
+ * as the foundation for all policy merging.
+ */
+export declare const defaultPolicy: Policy;
+/**
+ * A permissive policy preset optimized for developer‑friendly behavior.
+ *
+ * Lax mode applies no rejects or reviews, downgrades all severities by one
+ * level via a wildcard override, disables scan and analysis features, and
+ * allows structural exceptions for bigint, map, and set. This preset favors
+ * flexibility and forgiveness during development and experimentation.
+ */
+export declare const laxPolicy: Policy;
+/**
+ * A strict boundary preset that rejects on any issue.
+ *
+ * This configuration forces boundary acceptance to “strict”, applies a
+ * wildcard reject to treat every issue as fatal, and hides nothing from the
+ * event or issue streams. It provides the most conservative, compliance‑grade
+ * boundary behavior.
+ */
+export declare const boundaryPolicyStrict: BoundaryDecideConfig;
+/**
+ * The neutral boundary preset used when no boundary configuration is supplied.
+ *
+ * Default mode requires all fields to be accepted, applies no reject or review
+ * patterns, and hides nothing from the event or issue streams. It provides a
+ * transparent, assumption‑free baseline for boundary evaluation.
+ */
+export declare const boundaryPolicyDefault: BoundaryDecideConfig;
+/**
+ * A permissive boundary preset that accepts if any field succeeds.
+ *
+ * Lax mode ignores all boundary‑level events, hides both events and issues
+ * from the result, and applies no reject or review patterns. It provides a
+ * forgiving, low‑visibility boundary configuration suited for exploratory or
+ * developer‑focused workflows.
+ */
+export declare const boundaryPolicyLax: BoundaryDecideConfig;
+/**
+ * A maximum‑scrutiny policy preset for safety‑critical pipelines.
+ *
+ * Strict mode enables scan, rejects high‑risk conditions outright, escalates
+ * all severities by one level, and requires review for large or complex
+ * structures. All analysis features are enabled, and no structural exceptions
+ * are granted. This preset enforces the most conservative, defensive behavior.
+ */
+export declare const strictPolicy: Policy;
+export declare function mergeBoundaryPolicies(base: Partial<BoundaryDecideConfig> | undefined, ...overrides: Array<Partial<BoundaryDecideConfig> | undefined>): BoundaryDecideConfig;
+/**
+ * Merges a base policy with user‑supplied input into a final, normalized policy.
+ *
+ * This function applies field‑by‑field overrides, compiles public severity
+ * settings into internal override/escalation maps, and merges reject/review/warn
+ * patterns in a predictable order. It preserves all unspecified fields from the
+ * base policy and never introduces defaults beyond those already present.
+ */
+export declare function normalizePolicy(base: Policy, input?: PolicyInput): Policy;
+/**
+ * Resolves a numeric level for an event code from a sparse lookup table.
+ *
+ * Exact matches take priority. If none exist, wildcard patterns in the table
+ * are tested in insertion order using their compiled regular expressions.
+ * Returns the matched level or `undefined` when no pattern applies.
+ */
+export declare function resolveLevel(code: EventCode, table: Readonly<Partial<Record<string, number>>>): number | undefined;
+/**
+ * Applies policy transforms to events and produces the final pipeline decision.
+ *
+ * This function reshapes events using override, escalation, and warn rules,
+ * derives issues from the resulting severities, and evaluates reject/review
+ * patterns according to the active policy mode. It returns the full pipeline
+ * result with shaped events, extracted issues, and a final accept/review/reject
+ * decision. No data is modified—only event interpretation changes.
+ */
+export declare function policyDecision<T>(ctx: PolicyContext<T>, metadata: PipelineMetadata): PipelineResult<T>;
+/**
+ * Resolves the effective policy by merging defaults, explicit policy, and
+ * fluent‑API overrides.
+ *
+ * The default and explicit policies are combined first, then builder overrides
+ * are applied field‑by‑field with strict precedence. Only fields exposed to the
+ * fluent API are overrideable; all other structure is taken directly from the
+ * merged base. No inference or normalization occurs here—this function performs
+ * a final, literal merge for pipeline execution.
+ */
+export declare function resolvePolicy(defaultPolicy: Policy, janePolicy: Policy | undefined, overrides: PolicyOverrides | undefined): Policy;
+/**
+ * Returns the numeric index for a severity kind.
+ *
+ * Event kinds are stored in a fixed ordered list. Unknown kinds fall back to
+ * index 0 to guarantee a safe, deterministic baseline for all severity math.
+ * No interpretation occurs here—this is a simple lookup with a fallback.
+ */
+export declare function severityIndex(kind: EventKind): number;
+/**
+ * Fixed severity ladder from least to most severe.
+ *
+ * Policies, escalation math, and explain output rely on this exact ordering.
+ * Changing it is a breaking change because severity indices are used
+ * throughout the pipeline.
+ */
+export declare const SEVERITY_ORDER: readonly EventKind[];

package/dist/core/common/utilities.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Common | Utilities
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Shared low‑level helpers used across Jane’s core subsystems.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/**
+ * Performs structural deep equality on contained values.
+ *
+ * Primitives are compared by value, arrays and plain objects by shape and
+ * recursively by content, and Date objects by timestamp. Non‑plain objects
+ * are rejected. Cycle detection ensures safe comparison of recursive
+ * structures. This function defines the structural equality model used
+ * throughout Jane’s containment and diff logic.
+ */
+export declare function deepEqual(a: unknown, b: unknown, seen?: WeakMap<object, object>): boolean;
+/**
+ * Generates a unique run identifier.
+ *
+ * Uses `crypto.randomUUID` when available for strong, collision‑resistant IDs.
+ * Falls back to a timestamp + entropy string in environments without UUID
+ * support. Always returns a stable string suitable for pipeline metadata.
+ */
+export declare function generateRunId(): string;
+/**
+ * Checks for non‑null object values.
+ *
+ * Used as a minimal guard before structural checks. Functions, arrays, and
+ * plain objects all satisfy this test; it only excludes `null` and primitives.
+ */
+export declare function isObject(v: unknown): v is object;
+/**
+ * Checks whether a value is a strict plain object.
+ *
+ * Excludes arrays, null, and objects with custom or null prototypes. Only
+ * `{}`‑shaped values created by `Object` with `Object.prototype` qualify.
+ * Used wherever structural rules require predictable, JSON‑compatible objects.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks whether a value is a JavaScript primitive.
+ *
+ * Includes all scalar literals plus `null` and `undefined`. Anything that is
+ * not an object and not a function qualifies. Used as a fast‑path guard before
+ * structural or container‑level checks.
+ */
+export declare function isPrimitive(value: unknown): value is string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Safely stringifies arbitrary values for use in messages and telemetry.
+ *
+ * Primitives are returned directly, strings are truncated with JSON quoting,
+ * functions and symbols are rendered as descriptive sentinels, and objects are
+ * JSON‑encoded with circular‑reference protection. Output is always bounded by
+ * `maxLength` to prevent runaway logs or unreadable diagnostics.
+ */
+export declare function safeStringify(value: unknown, maxLength?: number): string;

package/dist/core/common/wildcard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Common | Wildcard
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Wildcard pattern helpers used for event‑code matching in policy rules.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { EventCode } from '../shapes';
+/**
+ * Compiles a wildcard pattern into a safe, anchored regular expression.
+ *
+ * Escapes all regex metacharacters except `*`, which expands to `.*`. The
+ * result matches the entire string, ensuring predictable event‑code pattern
+ * checks in policy rules.
+ */
+export declare function compileWildcard(pattern: string): RegExp;
+export declare function getCompiledWildcard(pattern: string): RegExp;
+/**
+ * Checks whether an event code matches any literal or wildcard pattern.
+ *
+ * Exact string matches take priority. Wildcard patterns are resolved through
+ * cached compiled expressions and tested in order. Returns `true` on the first
+ * match, otherwise `false`.
+ */
+export declare function matchesWildcard(code: EventCode, patterns: readonly string[]): boolean;

package/dist/core/field-path/construct.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Construct
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Constructors for creating canonical, immutable FieldPath
+ *                  objects.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { FieldPath, FieldPathSegment, InternalJsonValue, SegmentIndex, SegmentKey } from '../shapes';
+/**
+ * Appends a segment to an existing FieldPath.
+ *
+ * Produces a new canonical FieldPath by extending the current path’s segment
+ * list. Never mutates the original path.
+ */
+export declare function appendSegment(path: FieldPath, segment: FieldPathSegment): FieldPath;
+/**
+ * Produces a deep clone of an InternalJsonValue.
+ *
+ * Recursively copies arrays and plain objects while returning primitives,
+ * null, and undefined unchanged. Never mutates the input and never preserves
+ * references, ensuring safe use in diff, replay, and boundary evaluation.
+ */
+export declare function cloneContainer(value: InternalJsonValue): InternalJsonValue;
+/**
+ * Creates a shallow clone of a FieldPath.
+ *
+ * Copies the segment list into a new canonical FieldPath, ensuring callers
+ * never share mutable path state.
+ */
+export declare function clonePath(path: FieldPath): FieldPath;
+/**
+ * Creates a canonical FieldPath from a list of segments.
+ *
+ * Wraps the segment array with a stable toString() implementation and optional
+ * inputName. Produces a new immutable path object without modifying callers’
+ * data.
+ */
+export declare function makeFieldPath(segments: FieldPathSegment[], inputName?: string): FieldPath;
+/**
+ * Creates the root FieldPath.
+ *
+ * Produces an empty canonical path with an optional inputName. Used as the
+ * starting point for all path construction and never carries any segments.
+ */
+export declare const rootPath: (inputName?: string) => FieldPath;
+/**
+ * Sets a value at the given FieldPath.
+ *
+ * If the path is empty, returns the value directly. Otherwise delegates to the
+ * recursive setter, producing a new InternalJsonValue without mutating the
+ * original root.
+ */
+export declare function setAtPath(root: InternalJsonValue, path: FieldPath, value: InternalJsonValue): InternalJsonValue;
+/**
+ * Builds a FieldPath from the provided segments.
+ *
+ * Wraps the segment list in a canonical FieldPath object, ensuring callers
+ * always work with an immutable, well‑formed path representation.
+ */
+export declare const setFieldPath: (...segments: FieldPathSegment[]) => FieldPath;
+/**
+ * Creates an index segment.
+ *
+ * Wraps the numeric index in a canonical SegmentIndex object for use in
+ * FieldPath construction.
+ */
+export declare const setIndex: (index: number) => SegmentIndex;
+/**
+ * Creates a key segment.
+ *
+ * Wraps the string key in a canonical SegmentKey object for use in
+ * FieldPath construction.
+ */
+export declare const setKey: (key: string) => SegmentKey;

package/dist/core/field-path/format.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Format
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts FieldPath structures into stable, user‑facing
+ *                  string forms.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { FieldPath } from '../shapes';
+/**
+ * Converts a list of raw parts into a FieldPath.
+ *
+ * Maps numbers to index segments and strings to key segments, producing a
+ * canonical FieldPath suitable for formatting, traversal, or boundary work.
+ */
+export declare function arrayToFieldPath(parts: (string | number)[]): FieldPath;
+/**
+ * Converts a FieldPath into its raw parts.
+ *
+ * Extracts each segment’s key or index in order, producing a simple array
+ * representation suitable for serialization or comparison.
+ */
+export declare function fieldPathToArray(path: FieldPath): (string | number)[];
+/**
+ * Converts a FieldPath into a user‑facing string.
+ *
+ * Uses dotted notation for safe keys and bracket notation for indexes or
+ * keys requiring escaping. Produces a stable, readable form for logs,
+ * errors, and policy messages.
+ */
+export declare function fieldPathToUser(path: FieldPath): string;
+/**
+ * Parses a user‑facing path string into a FieldPath.
+ *
+ * Supports dotted keys, bracketed indexes, and quoted/escaped keys. Normalizes
+ * the "$" root form and walks the string character‑by‑character to build a
+ * canonical segment list suitable for traversal and boundary evaluation.
+ */
+export declare function userToFieldPath(user?: string): FieldPath;

package/dist/core/field-path/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports the Field Path modules to provide a unified
+ *                  public surface.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { appendSegment, cloneContainer, clonePath, makeFieldPath, rootPath, setAtPath, setFieldPath, setIndex, setKey, } from './construct';
+export { arrayToFieldPath, fieldPathToArray, fieldPathToUser, userToFieldPath } from './format';
+export { DANGEROUS_KEYS, escapeKey, isDangerousKey, isRoot, isSafeKey, lastSegment, parentPath, pathEquals, pathStartsWith, segmentsEqual, } from './utilities';
+export { walk, walkArray, walkObject } from './walk';

package/dist/core/field-path/utilities.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Utilities
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Small helper functions supporting FieldPath construction,
+ *                  parsing, and formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { FieldPath, FieldPathSegment } from '../shapes';
+/**
+ * Keys that must never appear in dotted notation.
+ *
+ * These properties interact with JavaScript’s prototype chain and are always
+ * forced into bracket‑notation to prevent prototype‑pollution vectors in
+ * formatting, parsing, and boundary evaluation.
+ */
+export declare const DANGEROUS_KEYS: Set<string>;
+/**
+ * Escapes a key for bracket notation.
+ *
+ * Uses JSON string rules to preserve all characters exactly, ensuring keys
+ * round‑trip cleanly through user‑facing formatting and parsing.
+ */
+export declare function escapeKey(key: string): string;
+/**
+ * Checks whether a key is unsafe for dotted notation.
+ *
+ * Identifies prototype‑chain properties that must always be emitted in
+ * bracket‑notation to avoid prototype‑pollution vectors.
+ */
+export declare function isDangerousKey(key: string): boolean;
+/**
+ * Checks whether a FieldPath refers to the root.
+ *
+ * A path is the root when it contains no segments, representing the top‑level
+ * position in traversal, formatting, and boundary evaluation.
+ */
+export declare const isRoot: (path: FieldPath) => boolean;
+/**
+ * Checks whether a key is safe for dotted notation.
+ *
+ * Rejects prototype‑chain properties and ensures the key matches JavaScript
+ * identifier rules, allowing it to appear unescaped in user‑facing paths.
+ */
+export declare function isSafeKey(key: string): boolean;
+/**
+ * Returns the final segment of a FieldPath.
+ *
+ * Useful when validators, scanners, or boundary logic need to inspect the
+ * current traversal position without mutating the path.
+ */
+export declare const lastSegment: (path: FieldPath) => FieldPathSegment | undefined;
+/**
+ * Returns the parent of a FieldPath.
+ *
+ * Removes the final segment to move one level up in traversal. Root paths
+ * remain stable—slicing an empty path yields another empty path.
+ */
+export declare function parentPath(path: FieldPath): FieldPath;
+/**
+ * Checks whether two FieldPaths are structurally identical.
+ *
+ * Paths are equal only when they contain the same number of segments and each
+ * corresponding segment matches, ensuring deterministic behavior in diff,
+ * explain, and boundary evaluation.
+ */
+export declare function pathEquals(a: FieldPath, b: FieldPath): boolean;
+/**
+ * Checks whether one FieldPath is a prefix of another.
+ *
+ * Path **a** starts with **b** when b has no more segments than a and each
+ * corresponding segment matches. Used by diff, explain, and boundary logic
+ * to determine whether a rule or change applies to a nested position.
+ */
+export declare function pathStartsWith(a: FieldPath, b: FieldPath): boolean;
+/**
+ * Checks whether two segments are structurally identical.
+ *
+ * Segments must share the same kind, and their key or index values must
+ * match exactly. This is the atomic comparison used by all path‑level
+ * equality and prefix checks.
+ */
+export declare const segmentsEqual: (a: FieldPathSegment, b: FieldPathSegment) => boolean;

package/dist/core/field-path/walk.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Field Path | Walk
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Traversal helpers that walk JSON‑like data with FieldPath
+ *                  context.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { FieldPath } from '../shapes';
+/**
+ * Recursively walks a JSON‑like value with FieldPath context.
+ *
+ * Visits the current node, then descends into arrays and plain objects,
+ * constructing child paths segment‑by‑segment. Prototype‑chain keys are
+ * skipped to avoid unsafe traversal during validation, scanning, and
+ * boundary evaluation.
+ */
+export declare function walk(value: unknown, path: FieldPath, visit: (value: unknown, path: FieldPath) => Promise<void>): Promise<void>;
+/**
+ * Visits each element of an array with FieldPath context.
+ *
+ * Emits a child path for every index and invokes the visitor without
+ * descending further. Used internally by higher‑level walkers that
+ * control recursion and traversal strategy.
+ */
+export declare function walkArray(value: readonly unknown[], path: FieldPath, visit: (child: unknown, childPath: FieldPath) => Promise<void>): Promise<void>;
+/**
+ * Visits each own property of an object with FieldPath context.
+ *
+ * Emits a child path for every safe key and invokes the visitor without
+ * descending further. Prototype‑chain keys are skipped to avoid unsafe
+ * traversal during validation, scanning, and boundary evaluation.
+ */
+export declare function walkObject(value: Record<string, unknown>, path: FieldPath, visit: (child: unknown, childPath: FieldPath) => Promise<void>): Promise<void>;

package/dist/core/fluent-registry.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Registry | Fluent
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Central registry of all built‑in validators and parsers.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/**
+ * Central registry of all built‑in Jane validators and parsers.
+ *
+ * This object provides a single, authoritative lookup table for every
+ * first‑party rule Jane ships with. Validators define how values are checked
+ * for correctness, while parsers convert raw input into structured forms.
+ * Keeping them together in one immutable registry ensures predictable
+ * resolution, consistent behavior across subsystems, and a stable surface
+ * for contributors extending or inspecting Jane’s rule set.
+ */
+export declare const janeRegistry: {
+    readonly validators: {
+        readonly alphaNum: import("./shapes").ValidationRule;
+        readonly alpha: import("./shapes").ValidationRule;
+        readonly array: import("./shapes").ValidationRule;
+        readonly arrayMinItems: (min: number) => import("./shapes").ValidationRule;
+        readonly arrayMaxItems: (max: number) => import("./shapes").ValidationRule;
+        readonly beforeEpoch: import("./shapes").ValidationRule;
+        readonly bigint: import("./shapes").ValidationRule;
+        readonly bigintEquals: (target: bigint) => import("./shapes").ValidationRule;
+        readonly bigintMax: (max: bigint) => import("./shapes").ValidationRule;
+        readonly bigintMin: (min: bigint) => import("./shapes").ValidationRule;
+        readonly bigintNegative: import("./shapes").ValidationRule;
+        readonly bigintNonNegative: import("./shapes").ValidationRule;
+        readonly bigintNonPositive: import("./shapes").ValidationRule;
+        readonly bigintPositive: import("./shapes").ValidationRule;
+        readonly bigintSafe: import("./shapes").ValidationRule;
+        readonly boolean: import("./shapes").ValidationRule;
+        readonly charsEqual: (exact: number) => import("./shapes").ValidationRule;
+        readonly dateNowRequired: import("./shapes").ValidationRule;
+        readonly deepEquals: (expected: unknown) => import("./shapes").ValidationRule;
+        readonly endsWith: (suffix: string) => import("./shapes").ValidationRule;
+        readonly excludes: (item: unknown) => import("./shapes").ValidationRule;
+        readonly finite: import("./shapes").ValidationRule;
+        readonly hasKey: (requiredKey: string) => import("./shapes").ValidationRule;
+        readonly hasUniqueItems: import("./shapes").ValidationRule;
+        readonly hasValue: (target: unknown) => import("./shapes").ValidationRule;
+        readonly includes: (item: unknown) => import("./shapes").ValidationRule;
+        readonly integer: import("./shapes").ValidationRule;
+        readonly isAscii: import("./shapes").ValidationRule;
+        readonly isCountryCode: import("./shapes").ValidationRule;
+        readonly isCurrencyCode: import("./shapes").ValidationRule;
+        readonly isDate: import("./shapes").ValidationRule;
+        readonly isEmail: import("./shapes").ValidationRule;
+        readonly isEmailStrict: import("./shapes").ValidationRule;
+        readonly isFalse: import("./shapes").ValidationRule;
+        readonly isFarFuture: import("./shapes").ValidationRule;
+        readonly isFuture: import("./shapes").ValidationRule;
+        readonly isIp: import("./shapes").ValidationRule;
+        readonly isPast: import("./shapes").ValidationRule;
+        readonly isPhone: import("./shapes").ValidationRule;
+        readonly isPhoneStrict: import("./shapes").ValidationRule;
+        readonly isPort: import("./shapes").ValidationRule;
+        readonly isPostalCode: import("./shapes").ValidationRule;
+        readonly isPrintable: import("./shapes").ValidationRule;
+        readonly isNull: import("./shapes").ValidationRule;
+        readonly isNullOrUndefined: import("./shapes").ValidationRule;
+        readonly isTrue: import("./shapes").ValidationRule;
+        readonly isUrl: import("./shapes").ValidationRule;
+        readonly isUndefined: import("./shapes").ValidationRule;
+        readonly isUuid: import("./shapes").ValidationRule;
+        readonly itemsEqual: (exact: number) => import("./shapes").ValidationRule;
+        readonly keysEqual: (expectedKeys: readonly string[]) => import("./shapes").ValidationRule;
+        readonly lessThan: (limit: number) => import("./shapes").ValidationRule;
+        readonly matches: (pattern: RegExp) => import("./shapes").ValidationRule;
+        readonly max: (limit: number) => import("./shapes").ValidationRule;
+        readonly maxKeys: (maximum: number) => import("./shapes").ValidationRule;
+        readonly maxLength: (max: number) => import("./shapes").ValidationRule;
+        readonly min: (limit: number) => import("./shapes").ValidationRule;
+        readonly minKeys: (minimum: number) => import("./shapes").ValidationRule;
+        readonly minLength: (min: number) => import("./shapes").ValidationRule;
+        readonly missingKey: (requiredKeys: readonly string[]) => import("./shapes").ValidationRule;
+        readonly moreThan: (limit: number) => import("./shapes").ValidationRule;
+        readonly negative: import("./shapes").ValidationRule;
+        readonly noEmptyArrayValues: import("./shapes").ValidationRule;
+        readonly noEmptyObjectValues: import("./shapes").ValidationRule;
+        readonly noEmptyStringItems: import("./shapes").ValidationRule;
+        readonly noLeadSpace: import("./shapes").ValidationRule;
+        readonly noNullItems: import("./shapes").ValidationRule;
+        readonly noNullValues: import("./shapes").ValidationRule;
+        readonly noRepeatSpace: import("./shapes").ValidationRule;
+        readonly noSpace: import("./shapes").ValidationRule;
+        readonly noTrailSpace: import("./shapes").ValidationRule;
+        readonly noUndefinedItems: import("./shapes").ValidationRule;
+        readonly noUndefinedValues: import("./shapes").ValidationRule;
+        readonly nonEmpty: import("./shapes").ValidationRule;
+        readonly nonEmptyArray: import("./shapes").ValidationRule;
+        readonly nonEmptyObject: import("./shapes").ValidationRule;
+        readonly nonNegative: import("./shapes").ValidationRule;
+        readonly nonPositive: import("./shapes").ValidationRule;
+        readonly notAfter: (max: Date) => import("./shapes").ValidationRule;
+        readonly notBefore: (min: Date) => import("./shapes").ValidationRule;
+        readonly notOneOf: (disallowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly notSparse: import("./shapes").ValidationRule;
+        readonly number: import("./shapes").ValidationRule;
+        readonly numString: import("./shapes").ValidationRule;
+        readonly oneOf: (allowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly onlyKeys: (allowed: readonly string[]) => import("./shapes").ValidationRule;
+        readonly plainObject: import("./shapes").ValidationRule;
+        readonly positive: import("./shapes").ValidationRule;
+        readonly safeInteger: import("./shapes").ValidationRule;
+        readonly sameDay: (other: Date) => import("./shapes").ValidationRule;
+        readonly sameMonth: (other: Date) => import("./shapes").ValidationRule;
+        readonly sameYear: (other: Date) => import("./shapes").ValidationRule;
+        readonly startsWith: (prefix: string) => import("./shapes").ValidationRule;
+        readonly string: import("./shapes").ValidationRule;
+        readonly tooEarly: (min: Date) => import("./shapes").ValidationRule;
+        readonly tooLate: (max: Date) => import("./shapes").ValidationRule;
+        readonly trimmed: import("./shapes").ValidationRule;
+        readonly weekday: (required: number) => import("./shapes").ValidationRule;
+        readonly weekend: import("./shapes").ValidationRule;
+    };
+    readonly parsers: {
+        readonly numeric: import("./shapes").ParseRule<unknown>;
+        readonly integer: import("./shapes").ParseRule<unknown>;
+        readonly boolean: import("./shapes").ParseRule<unknown>;
+        readonly bigint: import("./shapes").ParseRule<unknown>;
+        readonly hex: import("./shapes").ParseRule<unknown>;
+        readonly binary: import("./shapes").ParseRule<unknown>;
+        readonly octal: import("./shapes").ParseRule<unknown>;
+        readonly date: import("./shapes").ParseRule<unknown>;
+        readonly json: import("./shapes").ParseRule<unknown>;
+        readonly array: import("./shapes").ParseRule<unknown>;
+        readonly object: import("./shapes").ParseRule<unknown>;
+        readonly url: import("./shapes").ParseRule<string>;
+        readonly duration: import("./shapes").ParseRule<unknown>;
+        readonly scientific: import("./shapes").ParseRule<unknown>;
+    };
+};