"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonTypeBuilder = void 0;
const index_1 = require("../any/index");
const index_2 = require("../array/index");
const index_3 = require("../boolean/index");
const index_4 = require("../composite/index");
const index_5 = require("../const/index");
const index_6 = require("../deref/index");
const index_7 = require("../enum/index");
const index_8 = require("../exclude/index");
const index_9 = require("../extends/index");
const index_10 = require("../extract/index");
const index_11 = require("../indexed/index");
const index_12 = require("../integer/index");
const index_13 = require("../intersect/index");
const index_14 = require("../intrinsic/index");
const index_15 = require("../keyof/index");
const index_16 = require("../literal/index");
const index_17 = require("../mapped/index");
const index_18 = require("../never/index");
const index_19 = require("../not/index");
const index_20 = require("../null/index");
const index_21 = require("../number/index");
const index_22 = require("../object/index");
const index_23 = require("../omit/index");
const index_24 = require("../optional/index");
const index_25 = require("../partial/index");
const index_26 = require("../pick/index");
const index_27 = require("../readonly/index");
const index_28 = require("../readonly-optional/index");
const index_29 = require("../record/index");
const index_30 = require("../recursive/index");
const index_31 = require("../ref/index");
const index_32 = require("../required/index");
const index_33 = require("../rest/index");
const index_34 = require("../strict/index");
const index_35 = require("../string/index");
const index_36 = require("../template-literal/index");
const index_37 = require("../transform/index");
const index_38 = require("../tuple/index");
const index_39 = require("../union/index");
const index_40 = require("../unknown/index");
const index_41 = require("../unsafe/index");
/** Json Type Builder with Static Resolution for TypeScript */
class JsonTypeBuilder {
    // ------------------------------------------------------------------------
    // Strict
    // ------------------------------------------------------------------------
    /** `[Json]` Omits compositing symbols from this schema */
    Strict(schema) {
        return (0, index_34.Strict)(schema);
    }
    // ------------------------------------------------------------------------
    // Modifiers
    // ------------------------------------------------------------------------
    /** `[Json]` Creates a Readonly and Optional property */
    ReadonlyOptional(schema) {
        return (0, index_28.ReadonlyOptional)(schema);
    }
    /** `[Json]` Creates a Readonly property */
    Readonly(schema, enable) {
        return (0, index_27.Readonly)(schema, enable ?? true);
    }
    /** `[Json]` Creates a Optional property */
    Optional(schema, enable) {
        return (0, index_24.Optional)(schema, enable ?? true);
    }
    // ------------------------------------------------------------------------
    // Types
    // ------------------------------------------------------------------------
    /** `[Json]` Creates an Any type */
    Any(options = {}) {
        return (0, index_1.Any)(options);
    }
    /** `[Json]` Creates an Array type */
    Array(schema, options = {}) {
        return (0, index_2.Array)(schema, options);
    }
    /** `[Json]` Creates a Boolean type */
    Boolean(options = {}) {
        return (0, index_3.Boolean)(options);
    }
    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
    Capitalize(schema, options = {}) {
        return (0, index_14.Capitalize)(schema, options);
    }
    /** `[Json]` Creates a Composite object type */
    Composite(schemas, options) {
        return (0, index_4.Composite)(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
    }
    /** `[JavaScript]` Creates a readonly const type from the given value. */
    Const(value, options = {}) {
        return (0, index_5.Const)(value, options);
    }
    /** `[Json]` Creates a dereferenced type */
    Deref(schema, references) {
        return (0, index_6.Deref)(schema, references);
    }
    /** `[Json]` Creates a Enum type */
    Enum(item, options = {}) {
        return (0, index_7.Enum)(item, options);
    }
    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
    Exclude(unionType, excludedMembers, options = {}) {
        return (0, index_8.Exclude)(unionType, excludedMembers, options);
    }
    /** `[Json]` Creates a Conditional type */
    Extends(L, R, T, F, options = {}) {
        return (0, index_9.Extends)(L, R, T, F, options);
    }
    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
    Extract(type, union, options = {}) {
        return (0, index_10.Extract)(type, union, options);
    }
    /** `[Json]` Returns an Indexed property type for the given keys */
    Index(schema, unresolved, options = {}) {
        return (0, index_11.Index)(schema, unresolved, options);
    }
    /** `[Json]` Creates an Integer type */
    Integer(options = {}) {
        return (0, index_12.Integer)(options);
    }
    /** `[Json]` Creates an Intersect type */
    Intersect(T, options = {}) {
        return (0, index_13.Intersect)(T, options);
    }
    /** `[Json]` Creates a KeyOf type */
    KeyOf(schema, options = {}) {
        return (0, index_15.KeyOf)(schema, options);
    }
    /** `[Json]` Creates a Literal type */
    Literal(value, options = {}) {
        return (0, index_16.Literal)(value, options);
    }
    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
    Lowercase(schema, options = {}) {
        return (0, index_14.Lowercase)(schema, options);
    }
    /** `[Json]` Creates a Mapped object type */
    Mapped(key, map, options = {}) {
        return (0, index_17.Mapped)(key, map, options);
    }
    /** `[Json]` Creates a Never type */
    Never(options = {}) {
        return (0, index_18.Never)(options);
    }
    /** `[Json]` Creates a Not type */
    Not(schema, options) {
        return (0, index_19.Not)(schema, options);
    }
    /** `[Json]` Creates a Null type */
    Null(options = {}) {
        return (0, index_20.Null)(options);
    }
    /** `[Json]` Creates a Number type */
    Number(options = {}) {
        return (0, index_21.Number)(options);
    }
    /** `[Json]` Creates an Object type */
    Object(properties, options = {}) {
        return (0, index_22.Object)(properties, options);
    }
    /** `[Json]` Constructs a type whose keys are omitted from the given type */
    Omit(schema, unresolved, options = {}) {
        return (0, index_23.Omit)(schema, unresolved, options);
    }
    /** `[Json]` Constructs a type where all properties are optional */
    Partial(schema, options = {}) {
        return (0, index_25.Partial)(schema, options);
    }
    /** `[Json]` Constructs a type whose keys are picked from the given type */
    Pick(schema, unresolved, options = {}) {
        return (0, index_26.Pick)(schema, unresolved, options);
    }
    /** `[Json]` Creates a Record type */
    Record(key, schema, options = {}) {
        return (0, index_29.Record)(key, schema, options);
    }
    /** `[Json]` Creates a Recursive type */
    Recursive(callback, options = {}) {
        return (0, index_30.Recursive)(callback, options);
    }
    /** `[Json]` Creates a Ref type. */
    Ref(unresolved, options = {}) {
        return (0, index_31.Ref)(unresolved, options);
    }
    /** `[Json]` Constructs a type where all properties are required */
    Required(schema, options = {}) {
        return (0, index_32.Required)(schema, options);
    }
    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
    Rest(schema) {
        return (0, index_33.Rest)(schema);
    }
    /** `[Json]` Creates a String type */
    String(options = {}) {
        return (0, index_35.String)(options);
    }
    /** `[Json]` Creates a TemplateLiteral type */
    TemplateLiteral(unresolved, options = {}) {
        return (0, index_36.TemplateLiteral)(unresolved, options);
    }
    /** `[Json]` Creates a Transform type */
    Transform(schema) {
        return (0, index_37.Transform)(schema);
    }
    /** `[Json]` Creates a Tuple type */
    Tuple(items, options = {}) {
        return (0, index_38.Tuple)(items, options);
    }
    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
    Uncapitalize(schema, options = {}) {
        return (0, index_14.Uncapitalize)(schema, options);
    }
    /** `[Json]` Creates a Union type */
    Union(schemas, options = {}) {
        return (0, index_39.Union)(schemas, options);
    }
    /** `[Json]` Creates an Unknown type */
    Unknown(options = {}) {
        return (0, index_40.Unknown)(options);
    }
    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
    Unsafe(options = {}) {
        return (0, index_41.Unsafe)(options);
    }
    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
    Uppercase(schema, options = {}) {
        return (0, index_14.Uppercase)(schema, options);
    }
}
exports.JsonTypeBuilder = JsonTypeBuilder;
