@nhtio/validation 1.20250813.0 → 1.20250814.0

package/private/schemas.d.ts

@@ -2,9 +2,9 @@ import type { DateTime } from 'luxon';
 import type { PhoneSchema } from './schemas/phone';
 import type { BigIntSchema } from './schemas/bigint';
 import type { DatetimeSchema } from './schemas/datetime';
-import type { AnySchema as JoiAnySchema, StringSchema as JoiStringSchema, BinarySchema as JoiBinarySchema, NumberSchema as JoiNumberSchema, BooleanSchema as JoiBooleanSchema, ObjectSchema as JoiObjectSchema, ArraySchema as JoiArraySchema, DateSchema as JoiDateSchema, AlternativesSchema as JoiAlternativesSchema, Reference, BasicType, CustomHelpers, SchemaLikeWithoutArray } from 'joi';
+import type { default as Joi, AnySchema as JoiAnySchema, Reference, BasicType, CustomHelpers } from 'joi';
 export type DefaultableValue = Reference | BasicType | DateTime | bigint | ((parent: any, helpers: CustomHelpers) => Reference | BasicType | DateTime | bigint);
-export type ExtendedSchemaLikeWithoutArray = SchemaLikeWithoutArray | PhoneSchema | BigIntSchema | DatetimeSchema;
+export type ExtendedSchemaLikeWithoutArray = string | number | boolean | null | Schema | Joi.SchemaMap | PhoneSchema | BigIntSchema | DatetimeSchema;
 /**
  * Base schema type for all validation schemas.
  *
@@ -13,7 +13,55 @@ export type ExtendedSchemaLikeWithoutArray = SchemaLikeWithoutArray | PhoneSchem
  *
  * @public
  */
-export interface AnySchema<TSchema = any> extends Omit<JoiAnySchema<TSchema>, 'default'> {
+export interface AnySchema<TSchema = any> extends Omit<JoiAnySchema<TSchema>, 'allow' | 'alter' | 'artifact' | 'bind' | 'cache' | 'cast' | 'concat' | 'custom' | 'default' | 'description' | 'disallow' | 'empty' | 'equal' | 'error' | 'example' | 'exist' | 'external' | 'failover' | 'forbidden' | 'fork' | 'id' | 'invalid' | 'keep' | 'label' | 'message' | 'messages' | 'meta' | 'not' | 'note' | 'only' | 'optional' | 'options' | 'preferences' | 'prefs' | 'presence' | 'raw' | 'required' | 'rule' | 'shared' | 'strict' | 'strip' | 'tag' | 'unit' | 'valid' | 'warn' | 'warning' | 'when'> {
+    allow(...values: any[]): this;
+    alter(targets: Record<string, (schema: this) => Schema>): this;
+    artifact(id: any): this;
+    bind(): this;
+    cache(cache?: Joi.Cache): this;
+    concat(schema: this): this;
+    custom(fn: Joi.CustomValidator, description?: string): this;
+    description(desc: string): this;
+    disallow(...values: any[]): this;
+    empty(schema?: Joi.SchemaLike): this;
+    equal(...values: any[]): this;
+    error(err: Error | Joi.ValidationErrorFunction): this;
+    example(value: any, options?: {
+        override: boolean;
+    }): this;
+    exist(): this;
+    external(method: Joi.ExternalValidationFunction, description?: string): this;
+    failover(value: any): this;
+    forbidden(): this;
+    fork(key: string | string[] | string[][], adjuster: Joi.SchemaFunction): this;
+    id(name?: string): this;
+    invalid(...values: any[]): this;
+    keep(): this;
+    label(name: string): this;
+    message(message: string): this;
+    messages(messages: Joi.LanguageMessages): this;
+    meta(meta: object): this;
+    not(...values: any[]): this;
+    note(...notes: string[]): this;
+    only(): this;
+    optional(): this;
+    options(options: Joi.ValidationOptions): this;
+    prefs(options: Joi.ValidationOptions): this;
+    preferences(options: Joi.ValidationOptions): this;
+    presence(mode: Joi.PresenceMode): this;
+    raw(enabled?: boolean): this;
+    required(): this;
+    rule(options: Joi.RuleOptions): this;
+    shared(ref: Schema): this;
+    strict(isStrict?: boolean): this;
+    strip(enabled?: boolean): this;
+    tag(...tags: string[]): this;
+    unit(name: string): this;
+    valid(...values: any[]): this;
+    warn(): this;
+    warning(code: string, context: Joi.Context): this;
+    when(ref: string | Reference, options: Joi.WhenOptions | Joi.WhenOptions[]): this;
+    when(ref: Schema, options: Joi.WhenSchemaOptions): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -38,7 +86,142 @@ export interface AnySchema<TSchema = any> extends Omit<JoiAnySchema<TSchema>, 'd
  *
  * @public
  */
-export interface StringSchema<TSchema = string> extends Omit<JoiStringSchema<TSchema>, 'default'> {
+export interface StringSchema<TSchema = string> extends AnySchema<TSchema> {
+    /**
+     * Requires the string value to only contain a-z, A-Z, and 0-9.
+     */
+    alphanum(): this;
+    /**
+     * Requires the string value to be a valid base64 string; does not check the decoded value.
+     */
+    base64(options?: Joi.Base64Options): this;
+    /**
+     * Sets the required string case.
+     */
+    case(direction: 'upper' | 'lower'): this;
+    /**
+     * Requires the number to be a credit card number (Using Luhn Algorithm).
+     */
+    creditCard(): this;
+    /**
+     * Requires the string value to be a valid data URI string.
+     */
+    dataUri(options?: Joi.DataUriOptions): this;
+    /**
+     * Requires the string value to be a valid domain.
+     */
+    domain(options?: Joi.DomainOptions): this;
+    /**
+     * Requires the string value to be a valid email address.
+     */
+    email(options?: Joi.EmailOptions): this;
+    /**
+     * Requires the string value to be a valid GUID.
+     */
+    guid(options?: Joi.GuidOptions): this;
+    /**
+     * Requires the string value to be a valid hexadecimal string.
+     */
+    hex(options?: Joi.HexOptions): this;
+    /**
+     * Requires the string value to be a valid hostname as per RFC1123.
+     */
+    hostname(): this;
+    /**
+     * Allows the value to match any whitelist of blacklist item in a case insensitive comparison.
+     */
+    insensitive(): this;
+    /**
+     * Requires the string value to be a valid ip address.
+     */
+    ip(options?: Joi.IpOptions): this;
+    /**
+     * Requires the string value to be in valid ISO 8601 date format.
+     */
+    isoDate(): this;
+    /**
+     * Requires the string value to be in valid ISO 8601 duration format.
+     */
+    isoDuration(): this;
+    /**
+     * Specifies the exact string length required
+     * @param limit - the required string length. It can also be a reference to another field.
+     * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
+     */
+    length(limit: number | Reference, encoding?: string): this;
+    /**
+     * Requires the string value to be all lowercase. If the validation convert option is on (enabled by default), the string will be forced to lowercase.
+     */
+    lowercase(): this;
+    /**
+     * Specifies the maximum number of string characters.
+     * @param limit - the maximum number of string characters allowed. It can also be a reference to another field.
+     * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
+     */
+    max(limit: number | Reference, encoding?: string): this;
+    /**
+     * Specifies the minimum number string characters.
+     * @param limit - the minimum number of string characters required. It can also be a reference to another field.
+     * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
+     */
+    min(limit: number | Reference, encoding?: string): this;
+    /**
+     * Requires the string value to be in a unicode normalized form. If the validation convert option is on (enabled by default), the string will be normalized.
+     * @param [form='NFC'] - The unicode normalization form to use. Valid values: NFC [default], NFD, NFKC, NFKD
+     */
+    normalize(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD'): this;
+    /**
+     * Defines a regular expression rule.
+     * @param pattern - a regular expression object the string value must match against.
+     * @param options - optional, can be:
+     *   Name for patterns (useful with multiple patterns). Defaults to 'required'.
+     *   An optional configuration object with the following supported properties:
+     *     name - optional pattern name.
+     *     invert - optional boolean flag. Defaults to false behavior. If specified as true, the provided pattern will be disallowed instead of required.
+     */
+    pattern(pattern: RegExp, options?: string | Joi.StringRegexOptions): this;
+    /**
+     * Defines a regular expression rule.
+     * @param pattern - a regular expression object the string value must match against.
+     * @param options - optional, can be:
+     *   Name for patterns (useful with multiple patterns). Defaults to 'required'.
+     *   An optional configuration object with the following supported properties:
+     *     name - optional pattern name.
+     *     invert - optional boolean flag. Defaults to false behavior. If specified as true, the provided pattern will be disallowed instead of required.
+     */
+    regex(pattern: RegExp, options?: string | Joi.StringRegexOptions): this;
+    /**
+     * Replace characters matching the given pattern with the specified replacement string where:
+     * @param pattern - a regular expression object to match against, or a string of which all occurrences will be replaced.
+     * @param replacement - the string that will replace the pattern.
+     */
+    replace(pattern: RegExp | string, replacement: string): this;
+    /**
+     * Requires the string value to only contain a-z, A-Z, 0-9, and underscore _.
+     */
+    token(): this;
+    /**
+     * Requires the string value to contain no whitespace before or after. If the validation convert option is on (enabled by default), the string will be trimmed.
+     * @param [enabled=true] - optional parameter defaulting to true which allows you to reset the behavior of trim by providing a falsy value.
+     */
+    trim(enabled?: any): this;
+    /**
+     * Specifies whether the string.max() limit should be used as a truncation.
+     * @param [enabled=true] - optional parameter defaulting to true which allows you to reset the behavior of truncate by providing a falsy value.
+     */
+    truncate(enabled?: boolean): this;
+    /**
+     * Requires the string value to be all uppercase. If the validation convert option is on (enabled by default), the string will be forced to uppercase.
+     */
+    uppercase(): this;
+    /**
+     * Requires the string value to be a valid RFC 3986 URI.
+     */
+    uri(options?: Joi.UriOptions): this;
+    /**
+     * Requires the string value to be a valid GUID.
+     */
+    uuid(options?: Joi.GuidOptions): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -56,7 +239,23 @@ export interface StringSchema<TSchema = string> extends Omit<JoiStringSchema<TSc
  *
  * @public
  */
-export interface BinarySchema<TSchema = Buffer> extends Omit<JoiBinarySchema<TSchema>, 'default'> {
+export interface BinarySchema<TSchema = Buffer> extends AnySchema<TSchema> {
+    /**
+     * Sets the string encoding format if a string input is converted to a buffer.
+     */
+    encoding(encoding: string): this;
+    /**
+     * Specifies the minimum length of the buffer.
+     */
+    min(limit: number | Reference): this;
+    /**
+     * Specifies the maximum length of the buffer.
+     */
+    max(limit: number | Reference): this;
+    /**
+     * Specifies the exact length of the buffer:
+     */
+    length(limit: number | Reference): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -74,7 +273,60 @@ export interface BinarySchema<TSchema = Buffer> extends Omit<JoiBinarySchema<TSc
  *
  * @public
  */
-export interface NumberSchema<TSchema = number> extends Omit<JoiNumberSchema<TSchema>, 'default'> {
+export interface NumberSchema<TSchema = number> extends AnySchema<TSchema> {
+    /**
+     * Specifies that the value must be greater than limit.
+     * It can also be a reference to another field.
+     */
+    greater(limit: number | Reference): this;
+    /**
+     * Requires the number to be an integer (no floating point).
+     */
+    integer(): this;
+    /**
+     * Specifies that the value must be less than limit.
+     * It can also be a reference to another field.
+     */
+    less(limit: number | Reference): this;
+    /**
+     * Specifies the maximum value.
+     * It can also be a reference to another field.
+     */
+    max(limit: number | Reference): this;
+    /**
+     * Specifies the minimum value.
+     * It can also be a reference to another field.
+     */
+    min(limit: number | Reference): this;
+    /**
+     * Specifies that the value must be a multiple of base.
+     */
+    multiple(base: number | Reference): this;
+    /**
+     * Requires the number to be negative.
+     */
+    negative(): this;
+    /**
+     * Requires the number to be a TCP port, so between 0 and 65535.
+     */
+    port(): this;
+    /**
+     * Requires the number to be positive.
+     */
+    positive(): this;
+    /**
+     * Specifies the maximum number of decimal places where:
+     * @param limit - the maximum number of decimal places allowed.
+     */
+    precision(limit: number): this;
+    /**
+     * Requires the number to be negative or positive.
+     */
+    sign(sign: 'positive' | 'negative'): this;
+    /**
+     * Allows the number to be outside of JavaScript's safety range (Number.MIN_SAFE_INTEGER & Number.MAX_SAFE_INTEGER).
+     */
+    unsafe(enabled?: any): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -92,7 +344,10 @@ export interface NumberSchema<TSchema = number> extends Omit<JoiNumberSchema<TSc
  *
  * @public
  */
-export interface BooleanSchema<TSchema = boolean> extends Omit<JoiBooleanSchema<TSchema>, 'default'> {
+export interface BooleanSchema<TSchema = boolean> extends AnySchema<TSchema> {
+    falsy(...values: Array<string | number | null>): this;
+    sensitive(enabled?: boolean): this;
+    truthy(...values: Array<string | number | null>): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -110,7 +365,104 @@ export interface BooleanSchema<TSchema = boolean> extends Omit<JoiBooleanSchema<
  *
  * @public
  */
-export interface ObjectSchema<TSchema = any> extends Omit<JoiObjectSchema<TSchema>, 'default'> {
+export interface ObjectSchema<TSchema = any> extends AnySchema<TSchema> {
+    /**
+     * Defines an all-or-nothing relationship between keys where if one of the peers is present, all of them are required as well.
+     *
+     * Optional settings must be the last argument.
+     */
+    and(...peers: Array<string | Joi.DependencyOptions>): this;
+    /**
+     * Appends the allowed object keys. If schema is null, undefined, or {}, no changes will be applied.
+     */
+    append(schema?: Joi.SchemaMap<TSchema>): this;
+    append<TSchemaExtended = any, T = TSchemaExtended>(schema?: Joi.SchemaMap<T>): ObjectSchema<T>;
+    /**
+     * Verifies an assertion where.
+     */
+    assert(ref: string | Reference, schema: Joi.SchemaLike, message?: string): this;
+    /**
+     * Requires the object to be an instance of a given constructor.
+     *
+     * @param constructor - the constructor function that the object must be an instance of.
+     * @param name - an alternate name to use in validation errors. This is useful when the constructor function does not have a name.
+     */
+    instance(constructor: Function, name?: string): this;
+    /**
+     * Sets or extends the allowed object keys.
+     */
+    keys(schema?: Joi.SchemaMap<TSchema>): this;
+    /**
+     * Specifies the exact number of keys in the object.
+     */
+    length(limit: number): this;
+    /**
+     * Specifies the maximum number of keys in the object.
+     */
+    max(limit: number | Reference): this;
+    /**
+     * Specifies the minimum number of keys in the object.
+     */
+    min(limit: number | Reference): this;
+    /**
+     * Defines a relationship between keys where not all peers can be present at the same time.
+     *
+     * Optional settings must be the last argument.
+     */
+    nand(...peers: Array<string | Joi.DependencyOptions>): this;
+    /**
+     * Defines a relationship between keys where one of the peers is required (and more than one is allowed).
+     *
+     * Optional settings must be the last argument.
+     */
+    or(...peers: Array<string | Joi.DependencyOptions>): this;
+    /**
+     * Defines an exclusive relationship between a set of keys where only one is allowed but none are required.
+     *
+     * Optional settings must be the last argument.
+     */
+    oxor(...peers: Array<string | Joi.DependencyOptions>): this;
+    /**
+     * Specify validation rules for unknown keys matching a pattern.
+     *
+     * @param pattern - a pattern that can be either a regular expression or a joi schema that will be tested against the unknown key names
+     * @param schema - the schema object matching keys must validate against
+     */
+    pattern(pattern: RegExp | Joi.SchemaLike, schema: Joi.SchemaLike, options?: Joi.ObjectPatternOptions): this;
+    /**
+     * Requires the object to be a Joi reference.
+     */
+    ref(): this;
+    /**
+     * Requires the object to be a `RegExp` object.
+     */
+    regex(): this;
+    /**
+     * Renames a key to another name (deletes the renamed key).
+     */
+    rename(from: string | RegExp, to: string, options?: Joi.RenameOptions): this;
+    /**
+     * Requires the object to be a Joi schema instance.
+     */
+    schema(type?: Joi.SchemaLike): this;
+    /**
+     * Overrides the handling of unknown keys for the scope of the current object only (does not apply to children).
+     */
+    unknown(allow?: boolean): this;
+    /**
+     * Requires the presence of other keys whenever the specified key is present.
+     */
+    with(key: string, peers: string | string[], options?: Joi.DependencyOptions): this;
+    /**
+     * Forbids the presence of other keys whenever the specified is present.
+     */
+    without(key: string, peers: string | string[], options?: Joi.DependencyOptions): this;
+    /**
+     * Defines an exclusive relationship between a set of keys. one of them is required but not at the same time.
+     *
+     * Optional settings must be the last argument.
+     */
+    xor(...peers: Array<string | Joi.DependencyOptions>): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -131,7 +483,47 @@ export interface ObjectSchema<TSchema = any> extends Omit<JoiObjectSchema<TSchem
  *
  * @public
  */
-export interface ArraySchema<TSchema = any[]> extends Omit<JoiArraySchema<TSchema>, 'default'> {
+export interface ArraySchema<TSchema = any[]> extends AnySchema<TSchema> {
+    /**
+     * Verifies that an assertion passes for at least one item in the array, where:
+     * `schema` - the validation rules required to satisfy the assertion. If the `schema` includes references, they are resolved against
+     * the array item being tested, not the value of the `ref` target.
+     */
+    has(schema: Joi.SchemaLike): this;
+    /**
+     * Specifies the exact number of items in the array.
+     */
+    length(limit: number | Reference): this;
+    /**
+     * Specifies the maximum number of items in the array.
+     */
+    max(limit: number | Reference): this;
+    /**
+     * Specifies the minimum number of items in the array.
+     */
+    min(limit: number | Reference): this;
+    /**
+     * Allow single values to be checked against rules as if it were provided as an array.
+     * enabled can be used with a falsy value to go back to the default behavior.
+     */
+    single(enabled?: any): this;
+    /**
+     * Sorts the array by given order.
+     */
+    sort(options?: Joi.ArraySortOptions): this;
+    /**
+     * Allow this array to be sparse.
+     * enabled can be used with a falsy value to go back to the default behavior.
+     */
+    sparse(enabled?: any): this;
+    /**
+     * Requires the array values to be unique.
+     * Remember that if you provide a custom comparator function,
+     * different types can be passed as parameter depending on the rules you set on items.
+     * Be aware that a deep equality is performed on elements of the array having a type of object,
+     * a performance penalty is to be expected for this kind of operation.
+     */
+    unique(comparator?: string | Joi.ComparatorFunction, options?: Joi.ArrayUniqueOptions): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -143,7 +535,24 @@ export interface ArraySchema<TSchema = any[]> extends Omit<JoiArraySchema<TSchem
      *   - `helpers` - Validation helper functions for custom validation logic
      */
     default(value?: DefaultableValue): this;
+    /**
+     * List the types allowed for the array values.
+     * If a given type is .required() then there must be a matching item in the array.
+     * If a type is .forbidden() then it cannot appear in the array.
+     * Required items can be added multiple times to signify that multiple items must be found.
+     * Errors will contain the number of items that didn't match.
+     * Any unmatched item having a label will be mentioned explicitly.
+     *
+     * @param type - a joi schema object to validate each array item against.
+     */
     items(...types: ExtendedSchemaLikeWithoutArray[]): this;
+    /**
+     * Lists the types in sequence order for the array values where:
+     * @param type - a joi schema object to validate against each array item in sequence order. type can be multiple values passed as individual arguments.
+     * If a given type is .required() then there must be a matching item with the same index position in the array.
+     * Errors will contain the number of items that didn't match.
+     * Any unmatched item having a label will be mentioned explicitly.
+     */
     ordered(...types: ExtendedSchemaLikeWithoutArray[]): this;
 }
 /**
@@ -151,7 +560,44 @@ export interface ArraySchema<TSchema = any[]> extends Omit<JoiArraySchema<TSchem
  *
  * @public
  */
-export interface DateSchema<TSchema = Date> extends Omit<JoiDateSchema<TSchema>, 'default'> {
+export interface DateSchema<TSchema = Date> extends AnySchema<TSchema> {
+    /**
+     * Specifies that the value must be greater than date.
+     * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+     * allowing to explicitly ensure a date is either in the past or in the future.
+     * It can also be a reference to another field.
+     */
+    greater(date: 'now' | Date | number | string | Reference): this;
+    /**
+     * Requires the string value to be in valid ISO 8601 date format.
+     */
+    iso(): this;
+    /**
+     * Specifies that the value must be less than date.
+     * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+     * allowing to explicitly ensure a date is either in the past or in the future.
+     * It can also be a reference to another field.
+     */
+    less(date: 'now' | Date | number | string | Reference): this;
+    /**
+     * Specifies the oldest date allowed.
+     * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+     * allowing to explicitly ensure a date is either in the past or in the future.
+     * It can also be a reference to another field.
+     */
+    min(date: 'now' | Date | number | string | Reference): this;
+    /**
+     * Specifies the latest date allowed.
+     * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+     * allowing to explicitly ensure a date is either in the past or in the future.
+     * It can also be a reference to another field.
+     */
+    max(date: 'now' | Date | number | string | Reference): this;
+    /**
+     * Requires the value to be a timestamp interval from Unix Time.
+     * @param type - the type of timestamp (allowed values are unix or javascript [default])
+     */
+    timestamp(type?: 'javascript' | 'unix'): this;
     /**
      * Sets a default value if the original value is `undefined`.
      *
@@ -169,7 +615,77 @@ export interface DateSchema<TSchema = Date> extends Omit<JoiDateSchema<TSchema>,
  *
  * @public
  */
-export interface AlternativesSchema<TSchema = any> extends Omit<JoiAlternativesSchema<TSchema>, 'default' | 'try'> {
+export interface AlternativesSchema<TSchema = any> extends AnySchema<TSchema> {
+    /**
+     * Adds a conditional alternative schema type, either based on another key value, or a schema peeking into the current value.
+     */
+    conditional(ref: string | Reference, options: Joi.WhenOptions | Joi.WhenOptions[]): this;
+    conditional(ref: Schema, options: Joi.WhenSchemaOptions): this;
+    /**
+     * Requires the validated value to match a specific set of the provided alternative.try() schemas.
+     * Cannot be combined with `alternatives.conditional()`.
+     */
+    match(mode: 'any' | 'all' | 'one'): this;
+    /**
+     * Adds an alternative schema type for attempting to match against the validated value.
+     */
     try(...types: ExtendedSchemaLikeWithoutArray[]): this;
     default(value?: DefaultableValue): this;
 }
+/**
+ * Schema type for function validation.
+ *
+ * @public
+ */
+export interface FunctionSchema<TSchema = Function> extends AnySchema<TSchema> {
+    /**
+     * Specifies the arity of the function where:
+     * @param n - the arity expected.
+     */
+    arity(n: number): this;
+    /**
+     * Requires the function to be a class.
+     */
+    class(): this;
+    /**
+     * Specifies the minimal arity of the function where:
+     * @param n - the minimal arity expected.
+     */
+    minArity(n: number): this;
+    /**
+     * Specifies the minimal arity of the function where:
+     * @param n - the minimal arity expected.
+     */
+    maxArity(n: number): this;
+}
+/**
+ * Schema type for link validation.
+ *
+ * @public
+ */
+export interface LinkSchema<TSchema = any> extends AnySchema<TSchema> {
+    /**
+     * Same as `any.concat()` but the schema is merged after the link is resolved which allows merging with schemas of the same type as the resolved link.
+     * Will throw an exception during validation if the merged types are not compatible.
+     */
+    concat(schema: Schema | Joi.Schema): this;
+    /**
+     * Initializes the schema after constructions for cases where the schema has to be constructed first and then initialized.
+     * If `ref` was not passed to the constructor, `link.ref()` must be called prior to usage.
+     */
+    ref(ref: string): this;
+}
+/**
+ * Schema type for symbol validation.
+ *
+ * @public
+ */
+export interface SymbolSchema<TSchema = symbol> extends AnySchema<TSchema> {
+    map(iterable: Iterable<[string | number | boolean | symbol, symbol]> | {
+        [key: string]: symbol;
+    }): this;
+}
+/**
+ * A union type that includes all schema types.
+ */
+export type Schema = AnySchema | StringSchema | BinarySchema | NumberSchema | BooleanSchema | ObjectSchema | ArraySchema | DateSchema | AlternativesSchema | FunctionSchema | LinkSchema | SymbolSchema | BigIntSchema | DatetimeSchema | PhoneSchema;

package/private/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AnySchema } from './schemas';
+import type { Schema } from './schemas';
 /**
  * Encodes a validation schema into a compressed, base64-encoded string for transport between environments.
  *
@@ -46,7 +46,7 @@ import type { AnySchema } from './schemas';
  *
  * @see {@link decode} For decoding schemas from encoded strings
  */
-export declare const encode: (schema: AnySchema) => string;
+export declare const encode: (schema: Schema) => string;
 /**
  * Decodes a base64-encoded schema string back into a usable validation schema.
  *
@@ -103,4 +103,4 @@ export declare const encode: (schema: AnySchema) => string;
  *
  * @see {@link encode} For encoding schemas into transportable strings
  */
-export declare const decode: (base64: string) => AnySchema;
+export declare const decode: (base64: string) => Schema;