import typia, { tags } from "typia";
 
export const checkCustomTag = typia.createIs<CustomTag>();
 
interface CustomTag {
  type: number & tags.Type<"uint32">;
 
  number?: number & tags.ExclusiveMinimum<19> & tags.Maximum<100>;
 
  string: string & tags.MinLength<3>;
 
  pattern: string & tags.Pattern<"^[a-z]+$">;
 
  /**
   * Type tag can perform union type.
   *
   * In here case, format can be oneof `ipv4` or `ipv6` format.
   */
  format: (string & (tags.Format<"ipv4"> | tags.Format<"ipv6">)) | null;
 
  /** In the Array case, only type tag can restrict element type. */
  array: Array<string & tags.Format<"uuid">> &
    tags.MinItems<3> &
    tags.MaxItems<100>;
 
  /** Also, only type tag can handle map type. */
  map: Map<
    number & tags.Type<"uint32">,
    Array<string & tags.Format<"uuid">> & tags.MinItems<1>
  >;
}

import typia from "typia";
import * as __typia_transform__isFormatIpv4 from "typia/lib/internal/_isFormatIpv4";
import * as __typia_transform__isFormatIpv6 from "typia/lib/internal/_isFormatIpv6";
import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid";
import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32";
 
export const checkCustomTag = (() => {
  const _io0 = (input) =>
    "number" === typeof input.type &&
    __typia_transform__isTypeUint32._isTypeUint32(input.type) &&
    (undefined === input.number ||
      ("number" === typeof input.number &&
        19 < input.number &&
        input.number <= 100)) &&
    "string" === typeof input.string &&
    3 <= input.string.length &&
    "string" === typeof input.pattern &&
    RegExp("^[a-z]+$").test(input.pattern) &&
    (null === input.format ||
      ("string" === typeof input.format &&
        (__typia_transform__isFormatIpv4._isFormatIpv4(input.format) ||
          __typia_transform__isFormatIpv6._isFormatIpv6(input.format)))) &&
    Array.isArray(input.array) &&
    3 <= input.array.length &&
    input.array.length <= 100 &&
    input.array.every(
      (elem) =>
        "string" === typeof elem &&
        __typia_transform__isFormatUuid._isFormatUuid(elem),
    ) &&
    input.map instanceof Map &&
    (() =>
      [...input.map].every(
        (elem) =>
          Array.isArray(elem) &&
          elem.length === 2 &&
          "number" === typeof elem[0] &&
          __typia_transform__isTypeUint32._isTypeUint32(elem[0]) &&
          Array.isArray(elem[1]) &&
          1 <= elem[1].length &&
          elem[1].every(
            (elem) =>
              "string" === typeof elem &&
              __typia_transform__isFormatUuid._isFormatUuid(elem),
          ),
      ))();
  return (input) => "object" === typeof input && null !== input && _io0(input);
})();

import typia, { tags } from "typia";
 
export const checkCustomTag = typia.createIs<CustomTag>();
 
interface CustomTag {
  type: number & tags.Type<"uint32">;
 
  number?: number & tags.ExclusiveMinimum<19> & tags.Maximum<100>;
 
  string: string & tags.MinLength<3>;
 
  pattern: string & tags.Pattern<"^[a-z]+$">;
 
  /**
   * Type tag can perform union type.
   *
   * In here case, format can be oneof `ipv4` or `ipv6` format.
   */
  format: (string & (tags.Format<"ipv4"> | tags.Format<"ipv6">)) | null;
 
  /** In the Array case, only type tag can restrict element type. */
  array: Array<string & tags.Format<"uuid">> &
    tags.MinItems<3> &
    tags.MaxItems<100>;
 
  /** Also, only type tag can handle map type. */
  map: Map<
    number & tags.Type<"uint32">,
    Array<string & tags.Format<"uuid">> & tags.MinItems<1>
  >;
}

import typia from "typia";
import * as __typia_transform__isFormatIpv4 from "typia/lib/internal/_isFormatIpv4";
import * as __typia_transform__isFormatIpv6 from "typia/lib/internal/_isFormatIpv6";
import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid";
import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32";
 
export const checkCustomTag = (() => {
  const _io0 = (input) =>
    "number" === typeof input.type &&
    __typia_transform__isTypeUint32._isTypeUint32(input.type) &&
    (undefined === input.number ||
      ("number" === typeof input.number &&
        19 < input.number &&
        input.number <= 100)) &&
    "string" === typeof input.string &&
    3 <= input.string.length &&
    "string" === typeof input.pattern &&
    RegExp("^[a-z]+$").test(input.pattern) &&
    (null === input.format ||
      ("string" === typeof input.format &&
        (__typia_transform__isFormatIpv4._isFormatIpv4(input.format) ||
          __typia_transform__isFormatIpv6._isFormatIpv6(input.format)))) &&
    Array.isArray(input.array) &&
    3 <= input.array.length &&
    input.array.length <= 100 &&
    input.array.every(
      (elem) =>
        "string" === typeof elem &&
        __typia_transform__isFormatUuid._isFormatUuid(elem),
    ) &&
    input.map instanceof Map &&
    (() =>
      [...input.map].every(
        (elem) =>
          Array.isArray(elem) &&
          elem.length === 2 &&
          "number" === typeof elem[0] &&
          __typia_transform__isTypeUint32._isTypeUint32(elem[0]) &&
          Array.isArray(elem[1]) &&
          1 <= elem[1].length &&
          elem[1].every(
            (elem) =>
              "string" === typeof elem &&
              __typia_transform__isFormatUuid._isFormatUuid(elem),
          ),
      ))();
  return (input) => "object" === typeof input && null !== input && _io0(input);
})();

import typia, { tags } from "typia";
 
export const checkCustomTag = typia.createIs<CustomTag>();
 
interface CustomTag {
  /** @type uint32 */
  type: number;
 
  number?: number & tags.ExclusiveMinimum<19> & tags.Maximum<100>;
 
  /** @minLength 3 */
  string: string;
 
  pattern: string & tags.Pattern<"^[a-z]+$">;
 
  /**
   * Type tag can perform union type.
   *
   * In here case, format can be oneof `ipv4` or `ipv6` format.
   */
  format: (string & (tags.Format<"ipv4"> | tags.Format<"ipv6">)) | null;
 
  /** In the Array case, only type tag can restrict element type. */
  array: Array<string & tags.Format<"uuid">> &
    tags.MinItems<3> &
    tags.MaxItems<100>;
 
  /** Also, only type tag can handle map type. */
  map: Map<
    number & tags.Type<"uint32">,
    Array<string & tags.Format<"uuid">> & tags.MinItems<1>
  >;
}

import typia from "typia";
import * as __typia_transform__isFormatIpv4 from "typia/lib/internal/_isFormatIpv4";
import * as __typia_transform__isFormatIpv6 from "typia/lib/internal/_isFormatIpv6";
import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid";
import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32";
 
export const checkCustomTag = (() => {
  const _io0 = (input) =>
    "number" === typeof input.type &&
    Math.floor(input.type) === input.type &&
    0 <= input.type &&
    input.type <= 4294967295 &&
    (undefined === input.number ||
      ("number" === typeof input.number &&
        19 < input.number &&
        input.number <= 100)) &&
    "string" === typeof input.string &&
    3 <= input.string.length &&
    "string" === typeof input.pattern &&
    RegExp("^[a-z]+$").test(input.pattern) &&
    (null === input.format ||
      ("string" === typeof input.format &&
        (__typia_transform__isFormatIpv4._isFormatIpv4(input.format) ||
          __typia_transform__isFormatIpv6._isFormatIpv6(input.format)))) &&
    Array.isArray(input.array) &&
    3 <= input.array.length &&
    input.array.length <= 100 &&
    input.array.every(
      (elem) =>
        "string" === typeof elem &&
        __typia_transform__isFormatUuid._isFormatUuid(elem),
    ) &&
    input.map instanceof Map &&
    (() =>
      [...input.map].every(
        (elem) =>
          Array.isArray(elem) &&
          elem.length === 2 &&
          "number" === typeof elem[0] &&
          __typia_transform__isTypeUint32._isTypeUint32(elem[0]) &&
          Array.isArray(elem[1]) &&
          1 <= elem[1].length &&
          elem[1].every(
            (elem) =>
              "string" === typeof elem &&
              __typia_transform__isFormatUuid._isFormatUuid(elem),
          ),
      ))();
  return (input) => "object" === typeof input && null !== input && _io0(input);
})();

/**
 * Base type for all typia validation tags.
 *
 * `TagBase` is the foundation for all typia type tags (constraints like
 * `Minimum`, `MaxLength`, `Format`, etc.). It attaches compile-time metadata to
 * TypeScript types using a phantom property pattern.
 *
 * The typia transformer reads these tags at compile time and generates
 * appropriate runtime validation code. The tags themselves have no runtime
 * presence - they exist only in the type system.
 *
 * This is an internal implementation detail. Use the specific tag types (e.g.,
 * {@link Minimum}, {@link Format}, {@link Pattern}) rather than `TagBase`
 * directly.
 *
 * @author Jeongho Nam - https://github.com/samchon
 * @template Props Tag properties defining validation behavior and schema output
 */
export type TagBase<
  Props extends TagBase.IProps<any, any, any, any, any, any>,
> = {
  /**
   * Compile-time marker property for typia transformer.
   *
   * This phantom property carries tag metadata in the type system. It is never
   * assigned at runtime - it exists only for the transformer to read during
   * compilation.
   */
  "typia.tag"?: Props;
};
export namespace TagBase {
  /**
   * Configuration interface for validation tag properties.
   *
   * Defines all the metadata a validation tag can specify, including what types
   * it applies to, how to validate values, and what to output in JSON Schema.
   *
   * @template Target Which primitive type(s) this tag can be applied to
   * @template Kind Unique identifier for this tag type
   * @template Value The constraint value specified by the user
   * @template Validate The validation expression to generate
   * @template Exclusive Whether this tag conflicts with others
   * @template Schema Additional JSON Schema properties to output
   */
  export interface IProps<
    Target extends
      | "boolean"
      | "bigint"
      | "number"
      | "string"
      | "array"
      | "object",
    Kind extends string,
    Value extends boolean | bigint | number | string | undefined,
    Validate extends
      | string
      | {
          [key in Target]?: string;
        },
    Exclusive extends boolean | string[],
    Schema extends object | undefined,
  > {
    /**
     * Target primitive type(s) this tag applies to.
     *
     * The transformer will error if the tag is applied to a property of a
     * different type. For example, `MinLength` targets `"string"` and cannot be
     * applied to numbers.
     */
    target: Target;
 
    /**
     * Unique identifier for this tag type.
     *
     * Used internally to identify the constraint kind. Examples: `"minimum"`,
     * `"maxLength"`, `"format"`, `"pattern"`.
     */
    kind: Kind;
 
    /**
     * User-configured constraint value.
     *
     * The value provided by the user when applying the tag. For `Minimum<5>`,
     * this would be `5`. For `Format<"email">`, this would be `"email"`.
     */
    value: Value;
 
    /**
     * Validation expression template.
     *
     * JavaScript expression string that validates the input value. Use `$input`
     * as a placeholder for the actual value. The expression is inserted into
     * the generated validation function.
     *
     * Can be a single string or an object mapping target types to different
     * expressions (for tags supporting multiple types).
     *
     * @example
     *   `"5 <= $input"`; // For Minimum<5>
     *
     * @example
     *   `"$input.length <= 10"`; // For MaxLength<10>
     */
    validate?: Validate;
 
    /**
     * Tag exclusivity configuration.
     *
     * Controls which other tags cannot be combined with this one:
     *
     * - `true`: No duplicate tags of the same kind allowed
     * - `string[]`: List of incompatible tag kinds
     * - `false` (default): No exclusivity restrictions
     *
     * For example, `Minimum` and `ExclusiveMinimum` are mutually exclusive -
     * only one can be applied to a property.
     *
     * @default false
     */
    exclusive?: Exclusive | string[];
 
    /**
     * Additional JSON Schema properties to output.
     *
     * Object containing schema properties to merge into the generated JSON
     * Schema for the annotated type. For `Minimum<5>`, this would be `{
     * minimum: 5 }`.
     */
    schema?: Schema;
  }
}

import { TagBase } from "./TagBase";
 
/**
 * Inclusive minimum value constraint (value >= min).
 *
 * `Minimum<N>` is a type tag that validates numeric values are greater than or
 * equal to the specified bound. Apply it to `number` or `bigint` properties
 * using TypeScript intersection types.
 *
 * This constraint is **mutually exclusive** with {@link ExclusiveMinimum} - you
 * cannot use both on the same property. Use `Minimum` for inclusive bounds (>=)
 * and `ExclusiveMinimum` for exclusive bounds (>).
 *
 * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
 * `typia.validate()`. It also generates `minimum` in JSON Schema output.
 *
 * @author Jeongho Nam - https://github.com/samchon
 * @example
 *   interface Product {
 *     // Price must be 0 or greater
 *     price: number & Minimum<0>;
 *     // Quantity must be at least 1
 *     quantity: number & Minimum<1>;
 *   }
 *
 * @template Value The minimum allowed value (inclusive)
 */
export type Minimum<Value extends number | bigint> = TagBase<{
  target: Value extends bigint ? "bigint" : "number";
  kind: "minimum";
  value: Value;
  validate: `${Cast<Value>} <= $input`;
  exclusive: ["minimum", "exclusiveMinimum"];
  schema: Value extends bigint
    ? { minimum: Numeric<Value> }
    : { minimum: Value };
}>;
 
type Cast<Value extends number | bigint> = Value extends number
  ? Value
  : `BigInt(${Value})`;
type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
  ? N
  : never;

import { TagBase } from "./TagBase";
 
/**
 * Numeric precision and bit-width type constraint.
 *
 * `Type<Value>` is a type tag that constrains numeric values to specific
 * bit-width representations. This is essential for Protocol Buffers
 * serialization and ensures values fit within their specified ranges.
 *
 * Available types:
 *
 * - `"int32"`: Signed 32-bit integer (-2,147,483,648 to 2,147,483,647)
 * - `"uint32"`: Unsigned 32-bit integer (0 to 4,294,967,295)
 * - `"int64"`: Signed 64-bit integer (for `number` or `bigint`)
 * - `"uint64"`: Unsigned 64-bit integer (for `number` or `bigint`)
 * - `"float"`: 32-bit floating point
 * - `"double"`: 64-bit floating point (default JavaScript number)
 *
 * For Protocol Buffers, integer types also determine the wire encoding. The
 * constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
 * `typia.validate()`. It generates appropriate `type` in JSON Schema.
 *
 * @author Jeongho Nam - https://github.com/samchon
 * @example
 *   interface Message {
 *     // 32-bit unsigned integer
 *     id: number & Type<"uint32">;
 *     // 64-bit signed integer as bigint
 *     timestamp: bigint & Type<"int64">;
 *     // 32-bit float for memory efficiency
 *     score: number & Type<"float">;
 *   }
 *
 * @template Value Numeric type identifier
 */
export type Type<
  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
> = TagBase<{
  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
  kind: "type";
  value: Value;
  validate: Value extends "int32"
    ? `$importInternal("isTypeInt32")($input)`
    : Value extends "uint32"
      ? `$importInternal("isTypeUint32")($input)`
      : Value extends "int64"
        ? {
            number: `$importInternal("isTypeInt64")($input)`;
            bigint: `true`;
          }
        : Value extends "uint64"
          ? {
              number: `$importInternal("isTypeUint64")($input)`;
              bigint: `BigInt(0) <= $input`;
            }
          : Value extends "float"
            ? `$importInternal("isTypeFloat")($input)`
            : `true`;
  exclusive: true;
  schema: Value extends "uint32" | "uint64"
    ? {
        type: "integer";
        minimum: 0;
      }
    : {
        type: Value extends "int32" | "uint32" | "int64" | "uint64"
          ? "integer"
          : "number";
      };
}>;

import { TagBase } from "./TagBase";
 
/**
 * Regular expression pattern constraint for strings.
 *
 * `Pattern<Regex>` is a type tag that validates string values match the
 * specified regular expression pattern. Apply it to `string` properties using
 * TypeScript intersection types.
 *
 * This constraint is **mutually exclusive** with {@link Format} - you cannot use
 * both on the same property. Use `Pattern` for custom regex validation, or
 * `Format` for standard formats (email, uuid, etc.).
 *
 * The pattern should be a valid JavaScript regular expression string without
 * the surrounding slashes. The entire string must match (implicit `^` and `$`
 * anchors).
 *
 * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
 * `typia.validate()`. It generates `pattern` in JSON Schema output.
 *
 * @author Jeongho Nam - https://github.com/samchon
 * @example
 *   interface Product {
 *     // SKU format: 3 letters, dash, 4 digits
 *     sku: string & Pattern<"^[A-Z]{3}-[0-9]{4}$">;
 *     // Phone number: digits and optional dashes
 *     phone: string & Pattern<"^[0-9-]+$">;
 *   }
 *
 * @template Value Regular expression pattern as a string literal
 */
export type Pattern<Value extends string> = TagBase<{
  target: "string";
  kind: "pattern";
  value: Value;
  validate: `RegExp("${Serialize<Value>}").test($input)`;
  exclusive: ["format", "pattern"];
  schema: {
    pattern: Value;
  };
}>;
 
type Serialize<T extends string, Output extends string = ""> = string extends T
  ? never
  : T extends ""
    ? Output
    : T extends `${infer P}${infer R}`
      ? Serialize<R, `${Output}${P extends keyof Escaper ? Escaper[P] : P}`>
      : never;
 
type Escaper = {
  '"': '\\"';
  "\\": "\\\\";
  "\b": "\\b";
  "\f": "\\f";
  "\n": "\\n";
  "\r": "\\r";
  "\t": "\\t";
};

import typia, { tags } from "typia";
 
export const checkSomething = typia.createIs<Something>();
 
//----
// DEFINE CUSTOM TYPE TAGS
//----
type Dollar = tags.TagBase<{
  kind: "dollar";
  target: "string";
  value: undefined;
  validate: `$input[0] === "$" && !isNaN(Number($input.substring(1).split(",").join("")))`;
}>;
 
type Postfix<Value extends string> = tags.TagBase<{
  kind: "postfix";
  target: "string";
  value: Value;
  validate: `$input.endsWith("${Value}")`;
}>;
 
type IsEven<Value extends number | bigint> = tags.TagBase<{
  kind: "isEven";
  target: Value extends number ? "number" : "bigint";
  value: undefined;
  validate: `$input % ${Numeric<2>} === ${Numeric<0>}`;
}>;
 
type Numeric<Value extends number | bigint> = Value extends number
  ? Value
  : `BigInt(${Value})`;
 
//----
// VALIDATION
//----
interface Something {
  dollar: string & Dollar;
  postfix: string & Postfix<"!!!">;
  isEven: number & IsEven<number>;
}

import typia from "typia";
 
export const checkSomething = (() => {
  const _io0 = (input) =>
    "string" === typeof input.dollar &&
    input.dollar[0] === "$" &&
    !isNaN(Number(input.dollar.substring(1).split(",").join(""))) &&
    "string" === typeof input.postfix &&
    input.postfix.endsWith("!!!") &&
    "number" === typeof input.isEven &&
    input.isEven % 2 === 0;
  return (input) => "object" === typeof input && null !== input && _io0(input);
})();