Type Utils
    Preparing search index...

    Variable RulesConst

    Rules: {
        Array: {
            max: (n: number) => [rule: "__Array.max__", args: [n: number]];
            min: (n: number) => [rule: "__Array.min__", args: [n: number]];
            optional: () => Optional;
            unique: (
                deepObject?: boolean,
            ) => [rule: "__Array.unique__", args: [deepObject: boolean]];
        };
        createRule: <
            Handler extends CustomHandler,
            RName extends string = string,
            Message extends string = string,
            Formator extends MessageFormator = MessageFormator,
        >(
            __namedParameters: CreateRuleArgs<RName, Handler, Message, Formator>,
        ) => CustomFactory<
            Parameters<ReturnType<Handler>>,
            RName,
            Parameters<Handler>[0],
        >;
        createSetRule: (
            _arg: unknown,
        ) => (
            rule: Rule,
        ) => Readonly<
            {
                setErrorMessage: (message: string) => Rule;
                setErrorMessageFormator: (
                    messageFormator: (...args: any[]) => string,
                ) => Rule;
            },
        >;
        getCustomRuleMessages: (rules: Custom[]) => string[];
        isCustom: <
            Args extends any[] = unknown[],
            RuleName extends string = string,
            Subject = unknown,
        >(
            arg: unknown,
        ) => arg is Custom<Args, RuleName, Subject>;
        isCustomHandler: <Args extends any[] = unknown[], Subject = unknown>(
            handler: unknown,
        ) => handler is CustomHandler<Args, Subject>;
        Number: {
            max: (
                n: number | bigint,
            ) => [rule: "__Number.max__", args: [n: number | bigint]];
            min: (
                n: number | bigint,
            ) => [rule: "__Number.min__", args: [n: number | bigint]];
            nonZero: () => [rule: "__Number.nonZero__", args: []];
            optional: () => Optional;
        };
        Optional: () => Optional;
        Record: {
            nonEmpty: () => [rule: "__Record.nonEmpty__", args: []];
            optional: () => Optional;
        };
        setRule: (
            rule: Rule,
        ) => Readonly<
            {
                setErrorMessage: (message: string) => Rule;
                setErrorMessageFormator: (
                    messageFormator: (...args: any[]) => string,
                ) => Rule;
            },
        >;
        String: {
            max: (
                n: number | bigint,
            ) => [rule: "__String.max__", args: [n: number | bigint]];
            min: (
                n: number | bigint,
            ) => [rule: "__String.min__", args: [n: number | bigint]];
            nonEmpty: () => [rule: "__String.nonEmpty__", args: []];
            optional: () => Optional;
            regex: (
                regex: RegExp,
            ) => [rule: "__String.regex__", args: [regex: RegExp]];
        };
        getRule<
            T extends
                | "optional"
                | "String.min"
                | "String.max"
                | "String.regex"
                | "String.nonEmpty"
                | "Number.nonZero"
                | "Number.max"
                | "Number.min"
                | "Array.min"
                | "Array.max"
                | "Array.unique"
                | "Record.nonEmpty",
        >(
            name: T,
        ): {
            "__Array.max__": (arg: unknown[], n: number) => boolean;
            "__Array.min__": (arg: unknown[], n: number) => boolean;
            "__Array.unique__": (arg: unknown[], deepObject: boolean) => boolean;
            "__Number.max__": (arg: number, n: number | bigint) => boolean;
            "__Number.min__": (arg: number, n: number | bigint) => boolean;
            "__Number.nonZero__": (arg: number) => boolean;
            __optional__: (arg: unknown) => arg is undefined;
            "__Record.nonEmpty__": (
                arg: Record<string | number | symbol, unknown>,
            ) => boolean;
            "__String.max__": (arg: string, n: number) => boolean;
            "__String.min__": (arg: string, n: number) => boolean;
            "__String.nonEmpty__": (arg: string) => boolean;
            "__String.regex__": (arg: string, regex: RegExp) => boolean;
        }[{
            "Array.max": "__Array.max__";
            "Array.min": "__Array.min__";
            "Array.unique": "__Array.unique__";
            "Number.max": "__Number.max__";
            "Number.min": "__Number.min__";
            "Number.nonZero": "__Number.nonZero__";
            optional: "__optional__";
            "Record.nonEmpty": "__Record.nonEmpty__";
            "String.max": "__String.max__";
            "String.min": "__String.min__";
            "String.nonEmpty": "__String.nonEmpty__";
            "String.regex": "__String.regex__";
        }[T]];
        getRule<
            T extends
                | "optional"
                | "String.min"
                | "String.max"
                | "String.regex"
                | "String.nonEmpty"
                | "Number.nonZero"
                | "Number.max"
                | "Number.min"
                | "Array.min"
                | "Array.max"
                | "Array.unique"
                | "Record.nonEmpty",
            R extends Rule,
        >(
            name: T,
        ): R;
        getRule<
            T extends
                | "__Number.nonZero__"
                | "__Number.max__"
                | "__Number.min__"
                | "__Array.max__"
                | "__Array.min__"
                | "__Array.unique__"
                | "__String.max__"
                | "__String.min__"
                | "__String.regex__"
                | "__String.nonEmpty__"
                | "__Record.nonEmpty__"
                | "__optional__",
        >(
            key: T,
        ): {
            "__Array.max__": (arg: unknown[], n: number) => boolean;
            "__Array.min__": (arg: unknown[], n: number) => boolean;
            "__Array.unique__": (arg: unknown[], deepObject: boolean) => boolean;
            "__Number.max__": (arg: number, n: number | bigint) => boolean;
            "__Number.min__": (arg: number, n: number | bigint) => boolean;
            "__Number.nonZero__": (arg: number) => boolean;
            __optional__: (arg: unknown) => arg is undefined;
            "__Record.nonEmpty__": (
                arg: Record<string | number | symbol, unknown>,
            ) => boolean;
            "__String.max__": (arg: string, n: number) => boolean;
            "__String.min__": (arg: string, n: number) => boolean;
            "__String.nonEmpty__": (arg: string) => boolean;
            "__String.regex__": (arg: string, regex: RegExp) => boolean;
        }[T];
        getRule<
            T extends
                | "__Number.nonZero__"
                | "__Number.max__"
                | "__Number.min__"
                | "__Array.max__"
                | "__Array.min__"
                | "__Array.unique__"
                | "__String.max__"
                | "__String.min__"
                | "__String.regex__"
                | "__String.nonEmpty__"
                | "__Record.nonEmpty__"
                | "__optional__",
            R extends Rule,
        >(
            key: T,
        ): R;
        isDefaultRule(rule: unknown): rule is Default;
        isRule(rule: unknown): rule is All;
        parseRule<R extends RuleTuple>(
            __namedParameters: R,
        ):
            | ((arg: number) => boolean)
            | ((arg: number, n: number | bigint) => boolean)
            | ((arg: number, n: number | bigint) => boolean)
            | ((arg: unknown[], n: number) => boolean)
            | ((arg: unknown[], n: number) => boolean)
            | ((arg: unknown[], deepObject: boolean) => boolean)
            | ((arg: string, n: number) => boolean)
            | ((arg: string, n: number) => boolean)
            | ((arg: string, regex: RegExp) => boolean)
            | ((arg: string) => boolean)
            | ((arg: Record<string | number | symbol, unknown>) => boolean)
            | ((arg: unknown) => arg is undefined);
        useCustomRules<T, U extends Custom<any[], string, any>>(
            guard: TypeGuard<T>,
            rule: U,
        ): TypeGuard<T>;
        useCustomRules<
            T,
            U1 extends Custom<any[], string, any>,
            U2 extends Custom<any[], string, any>,
        >(
            guard: TypeGuard<T>,
            rule: U1,
            rule2: U2,
        ): TypeGuard<T>;
        useCustomRules<
            T,
            U1 extends Custom<any[], string, any>,
            U2 extends Custom<any[], string, any>,
            U3 extends Custom<any[], string, any>,
        >(
            guard: TypeGuard<T>,
            rule: U1,
            rule2: U2,
            rule3: U3,
        ): TypeGuard<T>;
        useCustomRules<
            T,
            U1 extends Custom<any[], string, any>,
            U2 extends Custom<any[], string, any>,
            U3 extends Custom<any[], string, any>,
            U4 extends Custom<any[], string, any>,
        >(
            guard: TypeGuard<T>,
            rule: U1,
            rule2: U2,
            rule3: U3,
            rule4: U4,
        ): TypeGuard<T>;
        useCustomRules<
            T,
            U1 extends Custom<any[], string, any>,
            U2 extends Custom<any[], string, any>,
            U3 extends Custom<any[], string, any>,
            U4 extends Custom<any[], string, any>,
            U5 extends Custom<any[], string, any>,
        >(
            guard: TypeGuard<T>,
            rule: U1,
            rule2: U2,
            rule3: U3,
            rule4: U4,
            rule5: U5,
        ): TypeGuard<T>;
        useCustomRules<
            T,
            U1 extends Custom<any[], string, any>,
            U2 extends Custom<any[], string, any>,
            U3 extends Custom<any[], string, any>,
            U4 extends Custom<any[], string, any>,
            U5 extends Custom<any[], string, any>,
            U extends Custom<any[], string, any>,
        >(
            guard: TypeGuard<T>,
            rule1: U1,
            rule2: U2,
            rule3: U3,
            rule4: U4,
            rule5: U5,
            ...rules: U[],
        ): TypeGuard<T>;
        useCustomRules<T, U extends Custom<any[], string, any>>(
            guard: TypeGuard<T>,
            ...rules: U[],
        ): TypeGuard<T>;
    } = ...

    Type declaration

    • Array: {
          max: (n: number) => [rule: "__Array.max__", args: [n: number]];
          min: (n: number) => [rule: "__Array.min__", args: [n: number]];
          optional: () => Optional;
          unique: (
              deepObject?: boolean,
          ) => [rule: "__Array.unique__", args: [deepObject: boolean]];
      }
    • createRule: <
          Handler extends CustomHandler,
          RName extends string = string,
          Message extends string = string,
          Formator extends MessageFormator = MessageFormator,
      >(
          __namedParameters: CreateRuleArgs<RName, Handler, Message, Formator>,
      ) => CustomFactory<
          Parameters<ReturnType<Handler>>,
          RName,
          Parameters<Handler>[0],
      >
    • createSetRule: (
          _arg: unknown,
      ) => (
          rule: Rule,
      ) => Readonly<
          {
              setErrorMessage: (message: string) => Rule;
              setErrorMessageFormator: (
                  messageFormator: (...args: any[]) => string,
              ) => Rule;
          },
      >
    • getCustomRuleMessages: (rules: Custom[]) => string[]
    • isCustom: <
          Args extends any[] = unknown[],
          RuleName extends string = string,
          Subject = unknown,
      >(
          arg: unknown,
      ) => arg is Custom<Args, RuleName, Subject>
    • isCustomHandler: <Args extends any[] = unknown[], Subject = unknown>(
          handler: unknown,
      ) => handler is CustomHandler<Args, Subject>
    • Number: {
          max: (
              n: number | bigint,
          ) => [rule: "__Number.max__", args: [n: number | bigint]];
          min: (
              n: number | bigint,
          ) => [rule: "__Number.min__", args: [n: number | bigint]];
          nonZero: () => [rule: "__Number.nonZero__", args: []];
          optional: () => Optional;
      }
    • Optional: () => Optional
    • Record: {
          nonEmpty: () => [rule: "__Record.nonEmpty__", args: []];
          optional: () => Optional;
      }
    • setRule: (
          rule: Rule,
      ) => Readonly<
          {
              setErrorMessage: (message: string) => Rule;
              setErrorMessageFormator: (
                  messageFormator: (...args: any[]) => string,
              ) => Rule;
          },
      >
    • String: {
          max: (
              n: number | bigint,
          ) => [rule: "__String.max__", args: [n: number | bigint]];
          min: (
              n: number | bigint,
          ) => [rule: "__String.min__", args: [n: number | bigint]];
          nonEmpty: () => [rule: "__String.nonEmpty__", args: []];
          optional: () => Optional;
          regex: (regex: RegExp) => [rule: "__String.regex__", args: [regex: RegExp]];
      }
    • getRule: function

      • Type Parameters

        • T extends
              | "optional"
              | "String.min"
              | "String.max"
              | "String.regex"
              | "String.nonEmpty"
              | "Number.nonZero"
              | "Number.max"
              | "Number.min"
              | "Array.min"
              | "Array.max"
              | "Array.unique"
              | "Record.nonEmpty"

        Parameters

        • name: T

        Returns {
            "__Array.max__": (arg: unknown[], n: number) => boolean;
            "__Array.min__": (arg: unknown[], n: number) => boolean;
            "__Array.unique__": (arg: unknown[], deepObject: boolean) => boolean;
            "__Number.max__": (arg: number, n: number | bigint) => boolean;
            "__Number.min__": (arg: number, n: number | bigint) => boolean;
            "__Number.nonZero__": (arg: number) => boolean;
            __optional__: (arg: unknown) => arg is undefined;
            "__Record.nonEmpty__": (
                arg: Record<string | number | symbol, unknown>,
            ) => boolean;
            "__String.max__": (arg: string, n: number) => boolean;
            "__String.min__": (arg: string, n: number) => boolean;
            "__String.nonEmpty__": (arg: string) => boolean;
            "__String.regex__": (arg: string, regex: RegExp) => boolean;
        }[{
            "Array.max": "__Array.max__";
            "Array.min": "__Array.min__";
            "Array.unique": "__Array.unique__";
            "Number.max": "__Number.max__";
            "Number.min": "__Number.min__";
            "Number.nonZero": "__Number.nonZero__";
            optional: "__optional__";
            "Record.nonEmpty": "__Record.nonEmpty__";
            "String.max": "__String.max__";
            "String.min": "__String.min__";
            "String.nonEmpty": "__String.nonEmpty__";
            "String.regex": "__String.regex__";
        }[T]]

      • Type Parameters

        • T extends
              | "optional"
              | "String.min"
              | "String.max"
              | "String.regex"
              | "String.nonEmpty"
              | "Number.nonZero"
              | "Number.max"
              | "Number.min"
              | "Array.min"
              | "Array.max"
              | "Array.unique"
              | "Record.nonEmpty"
        • R extends Rule

        Parameters

        • name: T

        Returns R

      • Type Parameters

        • T extends
              | "__Number.nonZero__"
              | "__Number.max__"
              | "__Number.min__"
              | "__Array.max__"
              | "__Array.min__"
              | "__Array.unique__"
              | "__String.max__"
              | "__String.min__"
              | "__String.regex__"
              | "__String.nonEmpty__"
              | "__Record.nonEmpty__"
              | "__optional__"

        Parameters

        • key: T

        Returns {
            "__Array.max__": (arg: unknown[], n: number) => boolean;
            "__Array.min__": (arg: unknown[], n: number) => boolean;
            "__Array.unique__": (arg: unknown[], deepObject: boolean) => boolean;
            "__Number.max__": (arg: number, n: number | bigint) => boolean;
            "__Number.min__": (arg: number, n: number | bigint) => boolean;
            "__Number.nonZero__": (arg: number) => boolean;
            __optional__: (arg: unknown) => arg is undefined;
            "__Record.nonEmpty__": (
                arg: Record<string | number | symbol, unknown>,
            ) => boolean;
            "__String.max__": (arg: string, n: number) => boolean;
            "__String.min__": (arg: string, n: number) => boolean;
            "__String.nonEmpty__": (arg: string) => boolean;
            "__String.regex__": (arg: string, regex: RegExp) => boolean;
        }[T]

      • Type Parameters

        • T extends
              | "__Number.nonZero__"
              | "__Number.max__"
              | "__Number.min__"
              | "__Array.max__"
              | "__Array.min__"
              | "__Array.unique__"
              | "__String.max__"
              | "__String.min__"
              | "__String.regex__"
              | "__String.nonEmpty__"
              | "__Record.nonEmpty__"
              | "__optional__"
        • R extends Rule

        Parameters

        • key: T

        Returns R

    • isDefaultRule: function
    • isRule: function
    • parseRule: function

      • Type Parameters

        Parameters

        • __namedParameters: R

        Returns
            | ((arg: number) => boolean)
            | ((arg: number, n: number | bigint) => boolean)
            | ((arg: number, n: number | bigint) => boolean)
            | ((arg: unknown[], n: number) => boolean)
            | ((arg: unknown[], n: number) => boolean)
            | ((arg: unknown[], deepObject: boolean) => boolean)
            | ((arg: string, n: number) => boolean)
            | ((arg: string, n: number) => boolean)
            | ((arg: string, regex: RegExp) => boolean)
            | ((arg: string) => boolean)
            | ((arg: Record<string | number | symbol, unknown>) => boolean)
            | ((arg: unknown) => arg is undefined)

    • useCustomRules: function

    Settings

    Member Visibility