@aventara/core 1.0.0-rc.0 → 1.0.0-rc.1

package/dist/adapters/adapter.interface.d.ts

@@ -1,50 +1,70 @@
-import type { CreateRequirementTable } from "../runtime/create-requirement.js";
 import type { ReferentialActionTable } from "../runtime/referential-action.js";
-import type { AdapterModel } from "./adapter-model.js";
-import type { AdapterOperationExecutor } from "./adapter-operation-executor.interface.js";
+import type { AvAdapterModel } from "./adapter-model.js";
+import type { AvAdapterOperationExecutor } from "./adapter-operation-executor.interface.js";
+import type { AvAdapterSqlStatement } from "./adapter-sql-statement.js";
+import type { AvAdapterTransactionExecutor } from "./adapter-transaction-executor.interface.js";
 /** Provider-specific implementation of Aventara discovery and execution. */
-export interface Adapter<M extends AdapterModel = AdapterModel> extends AdapterOperationExecutor<M> {
+export interface AvAdapter<M extends AvAdapterModel = AvAdapterModel> extends AvAdapterOperationExecutor<M> {
     /**
      * What the adapter discovered about the data source, in Aventara's vocabulary.
      * Read once, synchronously, when the framework is constructed.
      */
     readonly model: M;
     /**
-     * Optional referential actions: for each Resource that holds a reference,
-     * every relation holding one — the fields that hold it (`references`) and
-     * what deleting a referenced row does to its rows. Read once when the
-     * framework is constructed; never part of a Contract or its hash.
+     * Optional referential actions: for each Resource that holds a reference, every
+     * relation holding one: the fields that hold it (`references`) and what deleting a
+     * referenced row does to its rows. Read once when the framework is constructed;
+     * never part of a Contract or its hash.
+     *
+     * An edge listed under Resource `R` says that deleting a `target` row does
+     * `onDelete` to rows of `R`, and that `R`'s `references` fields hold the relation
+     * `field`'s reference.
      *
-     * An edge listed under Resource `R` says **deleting a `target` row does
-     * `onDelete` to rows of `R`**, and that `R`'s `references` fields hold the
-     * relation `field`'s reference.
+     * The same edges say which side of a relation holds its key: a nested `$connect`,
+     * `$disconnect` or `$set` on a to-one relation the parent holds runs none of the
+     * target's stages, and otherwise runs the target's `update` guards.
      *
-     * When absent, no cascade is planned and no transaction plan is refused
-     * because of one (`V1019`); a write that sets a relation and a field holding
-     * its reference both is not refused before the store; and a required
-     * relation can be satisfied only by writing the relation.
+     * When absent, no cascade is planned and no transaction plan is refused because of
+     * one (`V1019`); a write that sets a relation and a field holding its reference
+     * both is not refused before the store; and every nested `$connect`, `$disconnect`
+     * or `$set` runs the target's `update` guards.
      */
     readonly referentialActions?: ReferentialActionTable;
     /**
-     * Optional create requirements: for each Resource, the values its store
-     * cannot create a row without. Read once when the framework is constructed;
-     * never part of a Contract or its hash.
+     * Optional: `true` when the Adapter runs developer SQL statements: standalone
+     * through its own {@link executeSql}, and, when it has `transaction`, inside a
+     * transaction through the `executeSql` of the executor that callback is handed
+     * (`AvAdapterTransactionExecutor.executeSql`). `framework.appTx.$sql` steps and
+     * `ctx.$sql` need it. Read once when the framework is constructed; never part
+     * of a Contract or its hash.
+     *
+     * When absent, a plan holding an `appTx.$sql` step is refused before the
+     * transaction opens (`A2002`/`V1006` at the step), and so is every `ctx.$sql`.
+     */
+    readonly sqlStatements?: boolean;
+    /**
+     * Runs one developer SQL statement outside any transaction, as a plain
+     * statement, every value bound as a parameter, and resolves the rows it
+     * returned (none for a statement that returns no rows). Present exactly when
+     * the Adapter declares `sqlStatements`. `ctx.$sql` outside a transaction runs
+     * through it.
      *
-     * When absent, creates are not checked for missing values before they reach
-     * the store.
+     * A failure is thrown like an operation's: a deliberate `AvError` for an
+     * outcome the Adapter classified, anything else to be answered `A3001`.
      */
-    readonly createRequirements?: CreateRequirementTable;
+    executeSql?(statement: AvAdapterSqlStatement): Promise<readonly unknown[]>;
     /**
      * Optional callback transaction capability, required exactly when the
      * discovered model declares `transactions: "interactive"`. The callback
-     * receives only a transaction-scoped operation executor, never the provider
-     * client itself, and every operation of a plan executes through it.
+     * receives only a transaction-scoped executor, never the provider client
+     * itself, and every step of a plan executes through it.
      *
-     * The implementation must reject with the exact value `work` threw — by identity,
-     * never a wrapper — and must not resolve after `work` rejected; rollback is
-     * implied by that rejection. Guards, pipes, hooks and interceptors of every plan
-     * operation run inside `work` while the provider transaction is open, so they must
-     * not perform network I/O or unrelated slow work.
+     * The implementation must reject with the exact value `work` threw (by identity,
+     * never a wrapper) and must not resolve after `work` rejected; rollback is
+     * implied by that rejection. Every step's interceptors and hooks, and the touched
+     * Resources' transaction stages, run inside `work` while the provider transaction
+     * is open, so they must not perform network I/O or unrelated slow work. A step's
+     * guards, pipes and validators run before it opens.
      */
-    transaction?<T>(work: (executor: AdapterOperationExecutor<M>) => Promise<T>): Promise<T>;
+    transaction?<T>(work: (executor: AvAdapterTransactionExecutor<M>) => Promise<T>): Promise<T>;
 }

package/dist/avz/avz-check.factory.d.ts

@@ -0,0 +1,83 @@
+import { type AvZCheck } from "./avz-check.registry.js";
+/** The fields a bound applies to, by the kind of value it was written as. */
+type BoundTarget<Value> = Value extends Date ? "datetime" : Value extends bigint ? "bigint" | "decimal" : "number" | "decimal";
+/** A value below `value`. */
+export declare const lt: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<BoundTarget<Value>>;
+/** A value at most `value`. */
+export declare const lte: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<BoundTarget<Value>>;
+/** A value above `value`. */
+export declare const gt: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<BoundTarget<Value>>;
+/** A value at least `value`. */
+export declare const gte: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<BoundTarget<Value>>;
+/** A value above zero. */
+export declare const positive: () => AvZCheck<"number" | "bigint" | "decimal">;
+/** A value at least zero. */
+export declare const nonnegative: () => AvZCheck<"number" | "bigint" | "decimal">;
+/** A value below zero. */
+export declare const negative: () => AvZCheck<"number" | "bigint" | "decimal">;
+/** A value at most zero. */
+export declare const nonpositive: () => AvZCheck<"number" | "bigint" | "decimal">;
+/** A multiple of `value` (not zero). */
+export declare const multipleOf: <const Value extends number | bigint>(value: Value) => AvZCheck<Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+/** A string of at most `maximum` characters (Unicode code points). */
+export declare const maxLength: (maximum: number) => AvZCheck<"string">;
+/** A string of at least `minimum` characters (Unicode code points). */
+export declare const minLength: (minimum: number) => AvZCheck<"string">;
+/** A string of exactly `length` characters (Unicode code points). */
+export declare const length: (exact: number) => AvZCheck<"string">;
+/** A list of at most `maximum` entries. */
+export declare const maxItems: (maximum: number) => AvZCheck<"list">;
+/** A list of at least `minimum` entries. */
+export declare const minItems: (minimum: number) => AvZCheck<"list">;
+/** Bytes of at most `maximum` in length. */
+export declare const maxSize: (maximum: number) => AvZCheck<"bytes">;
+/** Bytes of at least `minimum` in length. */
+export declare const minSize: (minimum: number) => AvZCheck<"bytes">;
+/** Bytes of exactly `size` in length. */
+export declare const size: (exact: number) => AvZCheck<"bytes">;
+/** A string `pattern` matches (a JavaScript regular expression; its flags count). */
+export declare const regex: (pattern: RegExp) => AvZCheck<"string">;
+/** A string containing `value`. */
+export declare const includes: (value: string) => AvZCheck<"string">;
+/** A string starting with `prefix`. */
+export declare const startsWith: (prefix: string) => AvZCheck<"string">;
+/** A string ending with `suffix`. */
+export declare const endsWith: (suffix: string) => AvZCheck<"string">;
+/** A string with no uppercase letter (A–Z). */
+export declare const lowercase: () => AvZCheck<"string">;
+/** A string with no lowercase letter (a–z). */
+export declare const uppercase: () => AvZCheck<"string">;
+export declare const email: () => AvZCheck<"string">;
+export declare const url: () => AvZCheck<"string">;
+export declare const emoji: () => AvZCheck<"string">;
+export declare const uuid: () => AvZCheck<"string">;
+export declare const guid: () => AvZCheck<"string">;
+export declare const nanoid: () => AvZCheck<"string">;
+export declare const cuid: () => AvZCheck<"string">;
+export declare const cuid2: () => AvZCheck<"string">;
+export declare const ulid: () => AvZCheck<"string">;
+export declare const xid: () => AvZCheck<"string">;
+export declare const ksuid: () => AvZCheck<"string">;
+export declare const ipv4: () => AvZCheck<"string">;
+export declare const ipv6: () => AvZCheck<"string">;
+export declare const cidrv4: () => AvZCheck<"string">;
+export declare const cidrv6: () => AvZCheck<"string">;
+export declare const base64: () => AvZCheck<"string">;
+export declare const base64url: () => AvZCheck<"string">;
+export declare const jsonString: () => AvZCheck<"string">;
+export declare const e164: () => AvZCheck<"string">;
+export declare const creditCard: () => AvZCheck<"string">;
+export declare const iban: () => AvZCheck<"string">;
+export declare const jwt: () => AvZCheck<"string">;
+/** zod's ISO 8601 formats, as `z.iso` names them. */
+export declare const iso: Readonly<{
+    /** A date-time in UTC (`Z`), seconds required, any fraction (`z.iso.datetime()`). */
+    datetime: () => AvZCheck<"string">;
+    /** A calendar date, `YYYY-MM-DD` (`z.iso.date()`). */
+    date: () => AvZCheck<"string">;
+    /** A time, `HH:MM` with optional seconds and fraction (`z.iso.time()`). */
+    time: () => AvZCheck<"string">;
+    /** A duration such as `P3DT4H` (`z.iso.duration()`). */
+    duration: () => AvZCheck<"string">;
+}>;
+export {};

package/dist/avz/avz-check.factory.js

@@ -0,0 +1,116 @@
+import { registerAvZCheck, } from "./avz-check.registry.js";
+const CHECK_PROTOTYPE = Object.freeze(Object.create(null));
+function build(data) {
+    const check = Object.freeze(Object.assign(Object.create(CHECK_PROTOTYPE), data));
+    registerAvZCheck(check, Object.freeze({ ...data }));
+    return check;
+}
+function bound(builder, value) {
+    if ((typeof value === "number" && Number.isFinite(value)) ||
+        typeof value === "bigint" ||
+        (value instanceof Date && !Number.isNaN(value.getTime()))) {
+        return value instanceof Date ? new Date(value.getTime()) : value;
+    }
+    throw new TypeError(`AvZ.${builder}: the bound must be a finite number, a bigint or a valid Date.`);
+}
+function count(builder, value) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+        return value;
+    }
+    throw new TypeError(`AvZ.${builder}: the length must be a non-negative integer.`);
+}
+function text(builder, value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new TypeError(`AvZ.${builder}: the text must be a string.`);
+}
+const range = (builder, check, inclusive) => (value) => build({ check, value: bound(builder, value), inclusive });
+const sign = (check, inclusive) => () => build({ check, value: 0, inclusive });
+export const lt = range("lt", "less_than", false);
+export const lte = range("lte", "less_than", true);
+export const gt = range("gt", "greater_than", false);
+export const gte = range("gte", "greater_than", true);
+export const positive = sign("greater_than", false);
+export const nonnegative = sign("greater_than", true);
+export const negative = sign("less_than", false);
+export const nonpositive = sign("less_than", true);
+export const multipleOf = (value) => {
+    const step = bound("multipleOf", value);
+    if (step instanceof Date || step === 0 || step === 0n) {
+        throw new TypeError("AvZ.multipleOf: the step must be a non-zero finite number or bigint.");
+    }
+    return build({ check: "multiple_of", value: step });
+};
+export const maxLength = (maximum) => build({ check: "max_length", maximum: count("maxLength", maximum) });
+export const minLength = (minimum) => build({ check: "min_length", minimum: count("minLength", minimum) });
+export const length = (exact) => build({ check: "length_equals", length: count("length", exact) });
+export const maxItems = (maximum) => build({
+    check: "max_length",
+    maximum: count("maxItems", maximum),
+    list: true,
+});
+export const minItems = (minimum) => build({
+    check: "min_length",
+    minimum: count("minItems", minimum),
+    list: true,
+});
+export const maxSize = (maximum) => build({ check: "max_size", maximum: count("maxSize", maximum) });
+export const minSize = (minimum) => build({ check: "min_size", minimum: count("minSize", minimum) });
+export const size = (exact) => build({ check: "size_equals", size: count("size", exact) });
+export const regex = (pattern) => {
+    if (!(pattern instanceof RegExp)) {
+        throw new TypeError("AvZ.regex: the pattern must be a RegExp.");
+    }
+    return build({
+        check: "string_format",
+        format: "regex",
+        pattern: { source: pattern.source, flags: pattern.flags },
+    });
+};
+export const includes = (value) => build({
+    check: "string_format",
+    format: "includes",
+    includes: text("includes", value),
+});
+export const startsWith = (prefix) => build({
+    check: "string_format",
+    format: "starts_with",
+    prefix: text("startsWith", prefix),
+});
+export const endsWith = (suffix) => build({
+    check: "string_format",
+    format: "ends_with",
+    suffix: text("endsWith", suffix),
+});
+export const lowercase = () => build({ check: "string_format", format: "lowercase" });
+export const uppercase = () => build({ check: "string_format", format: "uppercase" });
+const named = (format) => () => build({ check: "string_format", format });
+export const email = named("email");
+export const url = named("url");
+export const emoji = named("emoji");
+export const uuid = named("uuid");
+export const guid = named("guid");
+export const nanoid = named("nanoid");
+export const cuid = named("cuid");
+export const cuid2 = named("cuid2");
+export const ulid = named("ulid");
+export const xid = named("xid");
+export const ksuid = named("ksuid");
+export const ipv4 = named("ipv4");
+export const ipv6 = named("ipv6");
+export const cidrv4 = named("cidrv4");
+export const cidrv6 = named("cidrv6");
+export const base64 = named("base64");
+export const base64url = named("base64url");
+export const jsonString = named("json_string");
+export const e164 = named("e164");
+export const creditCard = named("credit_card");
+export const iban = named("iban");
+export const jwt = named("jwt");
+export const iso = Object.freeze({
+    datetime: named("datetime"),
+    date: named("date"),
+    time: named("time"),
+    duration: named("duration"),
+});

package/dist/avz/avz-check.registry.d.ts

@@ -0,0 +1,35 @@
+import type { AvFieldCheck } from "../contracts/field-check.js";
+declare const avzCheckTarget: unique symbol;
+/**
+ * What a check applies to: a field's scalar type (`int` and `float` are
+ * `"number"`), a Json Shape node (a string, a number or an integer), or a list's
+ * own length (`"list"`).
+ */
+export type AvZCheckTarget = "string" | "number" | "bigint" | "decimal" | "datetime" | "bytes" | "list";
+/**
+ * A declarative check built with `AvZ` from `@aventara/core/avz` (`AvZ.maxLength(80)`,
+ * `AvZ.email()`, …): a field validator, or a check on a Json Shape node.
+ */
+export interface AvZCheck<Target extends AvZCheckTarget = never> {
+    readonly [avzCheckTarget]: (target: Target) => void;
+}
+/**
+ * A check as `AvZ` built it: the Contract's form, except that a bound or a step
+ * is the value the developer wrote (a number, a bigint or a `Date`) until the
+ * compiler writes it in the form of the field it lands on.
+ */
+export type AvZAuthoredCheck = {
+    readonly check: "less_than" | "greater_than";
+    readonly value: number | bigint | Date;
+    readonly inclusive: boolean;
+} | {
+    readonly check: "multiple_of";
+    readonly value: number | bigint;
+} | Exclude<AvFieldCheck, {
+    readonly check: "less_than" | "greater_than" | "multiple_of";
+}>;
+/** Records `check` as built by `AvZ`. For `@aventara/core/avz` only. */
+export declare function registerAvZCheck(check: object, data: AvZAuthoredCheck): void;
+/** The check `value` is, or `undefined` when `AvZ` did not build it. */
+export declare function avzCheckOf(value: unknown): AvZAuthoredCheck | undefined;
+export {};

package/dist/avz/avz-check.registry.js

@@ -0,0 +1,9 @@
+const checks = new WeakMap();
+export function registerAvZCheck(check, data) {
+    checks.set(check, data);
+}
+export function avzCheckOf(value) {
+    return typeof value === "object" && value !== null
+        ? checks.get(value)
+        : undefined;
+}

package/dist/avz/avz.d.ts

@@ -0,0 +1,203 @@
+import type { JsonSchemaPrimitive, JsonShape, JsonShapeValue } from "../contracts/json-shape.js";
+import { type AvZCheck } from "./avz-check.registry.js";
+/** The forms a Json Shape takes. */
+export type AvZKind = "string" | "number" | "int" | "boolean" | "null" | "literal" | "enum" | "object" | "array" | "tuple" | "record" | "union" | "discriminatedUnion" | "optional" | "nullable";
+/** The checks a shape of one kind takes: a string's, a number's, a list's length; else none. */
+type AvZShapeCheck<Kind extends AvZKind> = Kind extends "string" ? AvZCheck<"string"> : Kind extends "number" | "int" ? AvZCheck<"number"> : Kind extends "array" ? AvZCheck<"list"> : never;
+/**
+ * A Json Shape built with {@link AvZ}: opaque, its `kind` and `check` its only
+ * members. Its TypeScript type is `AvZ.infer<typeof shape>`.
+ */
+export interface AvZShape<Value = unknown, Kind extends AvZKind = AvZKind> extends JsonShape<Value> {
+    readonly kind: Kind;
+    /**
+     * The same shape with `checks` added: a string takes length, pattern and
+     * format checks, a number or an integer takes bounds and `multipleOf`, an
+     * array takes `AvZ.minItems`/`AvZ.maxItems`. No other shape takes any.
+     */
+    check(...checks: readonly AvZShapeCheck<Kind>[]): this;
+}
+/** The fields of an object shape, by key. */
+export type AvZFields = {
+    readonly [key: string]: AvZShape;
+};
+declare const avzOptionalKey: unique symbol;
+/** Marks a shape whose object key may be left out. Type-level only. */
+interface AvZOptionalKey {
+    readonly [avzOptionalKey]: true;
+}
+type FieldKeysOptional<Fields extends AvZFields> = {
+    [Key in keyof Fields]: Fields[Key] extends AvZOptionalKey ? Key : never;
+}[keyof Fields];
+type Flatten<T> = {
+    [Key in keyof T]: T[Key];
+} & {};
+/** The value an object shape describes. */
+type AvZObjectValue<Fields extends AvZFields> = ObjectValueOf<Fields, FieldKeysOptional<Fields>>;
+type ObjectValueOf<Fields extends AvZFields, Optional extends keyof Fields> = Flatten<{
+    -readonly [Key in Exclude<keyof Fields, Optional>]: JsonShapeValue<Fields[Key]>;
+} & {
+    -readonly [Key in Optional]?: JsonShapeValue<Fields[Key]>;
+}>;
+/** An object shape: closed, so a key it does not declare is refused. */
+export interface AvZObject<Fields extends AvZFields = AvZFields> extends AvZShape<AvZObjectValue<Fields>, "object"> {
+    readonly fields: Fields;
+}
+/** A shape whose object key may be left out. */
+export interface AvZOptional<Inner extends AvZShape = AvZShape> extends AvZShape<JsonShapeValue<Inner> | undefined, "optional">, AvZOptionalKey {
+}
+/** A shape that also admits `null`. */
+export type AvZNullable<Inner extends AvZShape = AvZShape> = AvZShape<JsonShapeValue<Inner> | null, "nullable"> & (Inner extends AvZOptionalKey ? AvZOptionalKey : unknown);
+/** A value a literal shape may hold. */
+export type AvZLiteralValue = JsonSchemaPrimitive;
+/** What keys a record shape: any string, an enum's values or one literal. */
+type AvZRecordKey = AvZShape<string, "string"> | AvZShape<string, "enum"> | AvZShape<string, "literal">;
+/** An option of a discriminated union: an object whose discriminator is a literal or an enum. */
+type AvZDiscriminable<Discriminator extends string> = AvZObject<{
+    readonly [Key in Discriminator]: AvZShape<AvZLiteralValue, "literal"> | AvZShape<string, "enum">;
+} & AvZFields>;
+type TupleValue<Items extends readonly AvZShape[]> = {
+    -readonly [Index in keyof Items]: JsonShapeValue<Items[Index]>;
+};
+/**
+ * Builds Json Shapes (the type of a Json field, declared at
+ * `resources.<Resource>.fields.<field>.definition.json`) and checks in zod's
+ * vocabulary: a field's `validators`, and a shape node's `check(...)`. No
+ * refinements, transforms or defaults. Objects are closed: a key the shape does
+ * not declare is refused.
+ */
+export declare class AvZ {
+    private constructor();
+    /** Any string. */
+    static readonly string: () => AvZShape<string, "string">;
+    /** Any finite number. */
+    static readonly number: () => AvZShape<number, "number">;
+    /** An integer (a safe one). */
+    static readonly int: () => AvZShape<number, "int">;
+    /** `true` or `false`. */
+    static readonly boolean: () => AvZShape<boolean, "boolean">;
+    /** `null`. */
+    static readonly null: () => AvZShape<null, "null">;
+    /** Exactly `value`: a string, a finite number, a boolean or `null`. */
+    static readonly literal: <const Value extends AvZLiteralValue>(value: Value) => AvZShape<Value, "literal">;
+    /** One of `values`. */
+    static readonly enum: <const Values extends readonly [string, ...string[]]>(values: Values) => AvZShape<Values[number], "enum">;
+    /** An object with exactly these keys; `AvZ.optional` marks one that may be left out. */
+    static readonly object: <const Fields extends AvZFields>(fields: Fields) => AvZObject<Fields>;
+    /** A list of `item`s. */
+    static readonly array: <Item extends AvZShape>(item: Item) => AvZShape<JsonShapeValue<Item>[], "array">;
+    /** A list of exactly these items, in order. */
+    static readonly tuple: <const Items extends readonly [AvZShape, ...AvZShape[]]>(items: Items) => AvZShape<TupleValue<Items>, "tuple">;
+    /** An object of `value`s, keyed by any string, an enum's values or a literal. */
+    static readonly record: <Key extends AvZRecordKey, Value extends AvZShape>(key: Key, value: Value) => AvZShape<Record<JsonShapeValue<Key>, JsonShapeValue<Value>>, "record">;
+    /** Any one of `options`. */
+    static readonly union: <const Options extends readonly [AvZShape, AvZShape, ...AvZShape[]]>(options: Options) => AvZShape<JsonShapeValue<Options[number]>, "union">;
+    /** One of `options`, told apart by the literal or enum at `discriminator`. */
+    static readonly discriminatedUnion: <Discriminator extends string, const Options extends readonly [AvZDiscriminable<Discriminator>, ...AvZDiscriminable<Discriminator>[]]>(discriminator: Discriminator, options: Options) => AvZShape<JsonShapeValue<Options[number]>, "discriminatedUnion">;
+    /** An object key that may be left out. */
+    static readonly optional: <Inner extends AvZShape>(inner: Inner) => AvZOptional<Inner>;
+    /** `inner`, or `null`. */
+    static readonly nullable: <Inner extends AvZShape>(inner: Inner) => AvZNullable<Inner>;
+    /** A value below `value` (a number, a bigint or a `Date`). */
+    static readonly lt: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<Value extends Date ? "datetime" : Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+    /** A value at most `value` (a number, a bigint or a `Date`). */
+    static readonly lte: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<Value extends Date ? "datetime" : Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+    /** A value above `value` (a number, a bigint or a `Date`). */
+    static readonly gt: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<Value extends Date ? "datetime" : Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+    /** A value at least `value` (a number, a bigint or a `Date`). */
+    static readonly gte: <const Value extends number | bigint | Date>(value: Value) => AvZCheck<Value extends Date ? "datetime" : Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+    /** A value above zero. */
+    static readonly positive: () => AvZCheck<"number" | "bigint" | "decimal">;
+    /** A value at least zero. */
+    static readonly nonnegative: () => AvZCheck<"number" | "bigint" | "decimal">;
+    /** A value below zero. */
+    static readonly negative: () => AvZCheck<"number" | "bigint" | "decimal">;
+    /** A value at most zero. */
+    static readonly nonpositive: () => AvZCheck<"number" | "bigint" | "decimal">;
+    /** A multiple of `value`. */
+    static readonly multipleOf: <const Value extends number | bigint>(value: Value) => AvZCheck<Value extends bigint ? "bigint" | "decimal" : "number" | "decimal">;
+    /** A string of at most `maximum` characters; on a list field, each entry. */
+    static readonly maxLength: (maximum: number) => AvZCheck<"string">;
+    /** A string of at least `minimum` characters; on a list field, each entry. */
+    static readonly minLength: (minimum: number) => AvZCheck<"string">;
+    /** A string of exactly `length` characters; on a list field, each entry. */
+    static readonly length: (exact: number) => AvZCheck<"string">;
+    /** A list of at most `maximum` entries: a list field, or an array shape. */
+    static readonly maxItems: (maximum: number) => AvZCheck<"list">;
+    /** A list of at least `minimum` entries: a list field, or an array shape. */
+    static readonly minItems: (minimum: number) => AvZCheck<"list">;
+    /** Bytes of at most `maximum` in length. */
+    static readonly maxSize: (maximum: number) => AvZCheck<"bytes">;
+    /** Bytes of at least `minimum` in length. */
+    static readonly minSize: (minimum: number) => AvZCheck<"bytes">;
+    /** Bytes of exactly `size` in length. */
+    static readonly size: (exact: number) => AvZCheck<"bytes">;
+    /** A string the pattern matches: a JavaScript regular expression, flags included. */
+    static readonly regex: (pattern: RegExp) => AvZCheck<"string">;
+    /** A string containing `value`. */
+    static readonly includes: (value: string) => AvZCheck<"string">;
+    /** A string starting with `prefix`. */
+    static readonly startsWith: (prefix: string) => AvZCheck<"string">;
+    /** A string ending with `suffix`. */
+    static readonly endsWith: (suffix: string) => AvZCheck<"string">;
+    /** A string with no uppercase letter. */
+    static readonly lowercase: () => AvZCheck<"string">;
+    /** A string with no lowercase letter. */
+    static readonly uppercase: () => AvZCheck<"string">;
+    /** An email address. */
+    static readonly email: () => AvZCheck<"string">;
+    /** A URL. */
+    static readonly url: () => AvZCheck<"string">;
+    /** Emoji only. */
+    static readonly emoji: () => AvZCheck<"string">;
+    /** A UUID (any version). */
+    static readonly uuid: () => AvZCheck<"string">;
+    /** A GUID: any 8-4-4-4-12 hex identifier. */
+    static readonly guid: () => AvZCheck<"string">;
+    /** A Nano ID. */
+    static readonly nanoid: () => AvZCheck<"string">;
+    /** A CUID. */
+    static readonly cuid: () => AvZCheck<"string">;
+    /** A CUID2. */
+    static readonly cuid2: () => AvZCheck<"string">;
+    /** A ULID. */
+    static readonly ulid: () => AvZCheck<"string">;
+    /** An XID. */
+    static readonly xid: () => AvZCheck<"string">;
+    /** A KSUID. */
+    static readonly ksuid: () => AvZCheck<"string">;
+    /** An IPv4 address. */
+    static readonly ipv4: () => AvZCheck<"string">;
+    /** An IPv6 address. */
+    static readonly ipv6: () => AvZCheck<"string">;
+    /** An IPv4 CIDR block. */
+    static readonly cidrv4: () => AvZCheck<"string">;
+    /** An IPv6 CIDR block. */
+    static readonly cidrv6: () => AvZCheck<"string">;
+    /** Base64. */
+    static readonly base64: () => AvZCheck<"string">;
+    /** Base64url. */
+    static readonly base64url: () => AvZCheck<"string">;
+    /** A string that parses as JSON (zod's `json_string` format). */
+    static readonly jsonString: () => AvZCheck<"string">;
+    /** An E.164 phone number. */
+    static readonly e164: () => AvZCheck<"string">;
+    /** A credit card number (Luhn-checked). */
+    static readonly creditCard: () => AvZCheck<"string">;
+    /** An IBAN (checksum-checked). */
+    static readonly iban: () => AvZCheck<"string">;
+    /** A JWT. */
+    static readonly jwt: () => AvZCheck<"string">;
+    /** ISO 8601: `datetime`, `date`, `time` and `duration`. */
+    static readonly iso: Readonly<{
+        datetime: () => AvZCheck<"string">;
+        date: () => AvZCheck<"string">;
+        time: () => AvZCheck<"string">;
+        duration: () => AvZCheck<"string">;
+    }>;
+}
+export declare namespace AvZ {
+    /** The TypeScript type a shape describes. */
+    type infer<Shape extends JsonShape> = JsonShapeValue<Shape>;
+}
+export {};