@nmtjs/type 0.5.2 → 0.6.0

package/dist/types/any.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/any.ts"],"sourcesContent":["import { type TAny, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class AnyType extends BaseType<TAny> {\n  _!: ConstantType<this['schema']>\n\n  static factory() {\n    return new AnyType(Type.Any())\n  }\n}\n"],"names":["Type","BaseType","AnyType","_","factory","Any"],"mappings":"AAAA,SAAoBA,IAAI,QAAQ,oBAAmB;AACnD,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,gBAAgBD;IAC3BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,QAAQF,KAAKK,GAAG;IAC7B;AACF"}
+{"version":3,"sources":["../../../src/types/any.ts"],"sourcesContent":["import { type TAny, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class AnyType extends BaseType<TAny, {}, any> {\n  static factory() {\n    return new AnyType(Type.Any())\n  }\n}\n"],"names":["Type","BaseType","AnyType","factory","Any"],"mappings":"AAAA,SAAoBA,IAAI,QAAQ,oBAAmB;AACnD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,gBAAgBD;IAC3B,OAAOE,UAAU;QACf,OAAO,IAAID,QAAQF,KAAKI,GAAG;IAC7B;AACF"}

package/dist/types/array.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
-    _;
     static factory(element, options = {}) {
         return new ArrayType(Type.Array(element.schema, options));
     }

package/dist/types/array.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/array.ts"],"sourcesContent":["import {\n  type ArrayOptions,\n  type StaticDecode,\n  type TArray,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  TArray<T['schema']>,\n  { element: T; options: ArrayOptions }\n> {\n  _!: {\n    encoded: {\n      input: TArray<T['_']['encoded']['input']>\n      output: TArray<T['_']['encoded']['output']>\n    }\n    decoded: {\n      input: TArray<T['_']['decoded']['input']>\n      output: TArray<T['_']['decoded']['output']>\n    }\n  }\n\n  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {\n    return new ArrayType<T>(Type.Array(element.schema, options))\n  }\n\n  min(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n    })\n  }\n\n  max(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      maxItems: value,\n    })\n  }\n\n  length(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n      maxItems: value,\n    })\n  }\n}\n"],"names":["Type","BaseType","ArrayType","_","factory","element","options","Array","schema","min","value","props","minItems","max","maxItems","length"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAiDD;IAI5DE,EASC;IAED,OAAOC,QAA4BC,OAAU,EAAEC,UAAwB,CAAC,CAAC,EAAE;QACzE,OAAO,IAAIJ,UAAaF,KAAKO,KAAK,CAACF,QAAQG,MAAM,EAAEF;IACrD;IAEAG,IAAIC,KAAa,EAAE;QACjB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;QACZ;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBQ,UAAUJ;QACZ;IACF;IAEAK,OAAOL,KAAa,EAAE;QACpB,OAAOR,UAAUE,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;YACVI,UAAUJ;QACZ;IACF;AACF"}
+{"version":3,"sources":["../../../src/types/array.ts"],"sourcesContent":["import {\n  type ArrayOptions,\n  type StaticDecode,\n  type TArray,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  TArray<T['schema']>,\n  { element: T; options: ArrayOptions }\n> {\n  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {\n    return new ArrayType<T>(Type.Array(element.schema, options))\n  }\n\n  min(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n    })\n  }\n\n  max(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      maxItems: value,\n    })\n  }\n\n  length(value: number) {\n    return ArrayType.factory(this.props.element, {\n      ...this.props.options,\n      minItems: value,\n      maxItems: value,\n    })\n  }\n}\n"],"names":["Type","BaseType","ArrayType","factory","element","options","Array","schema","min","value","props","minItems","max","maxItems","length"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAiDD;IAI5D,OAAOE,QAA4BC,OAAU,EAAEC,UAAwB,CAAC,CAAC,EAAE;QACzE,OAAO,IAAIH,UAAaF,KAAKM,KAAK,CAACF,QAAQG,MAAM,EAAEF;IACrD;IAEAG,IAAIC,KAAa,EAAE;QACjB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;QACZ;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBQ,UAAUJ;QACZ;IACF;IAEAK,OAAOL,KAAa,EAAE;QACpB,OAAOP,UAAUC,OAAO,CAAC,IAAI,CAACO,KAAK,CAACN,OAAO,EAAE;YAC3C,GAAG,IAAI,CAACM,KAAK,CAACL,OAAO;YACrBM,UAAUF;YACVI,UAAUJ;QACZ;IACF;AACF"}

package/dist/types/base.js

@@ -1,16 +1,13 @@
 import { Optional } from '@sinclair/typebox';
+import { Default } from "../schemas/default.js";
 import { Nullable } from "../schemas/nullable.js";
 export class BaseType {
     schema;
-    final;
     props;
     params;
     constructor(schema, props = {}, params = {}){
         const { hasDefault = false, nullable = false, optional = false } = params;
         this.schema = schema;
-        this.final = schema;
-        if (nullable) this.final = Nullable(this.final);
-        if (optional || hasDefault) this.final = Optional(this.final);
         this.props = props;
         this.params = {
             hasDefault,
@@ -46,9 +43,8 @@ export class BaseType {
     }
 }
 export class OptionalType extends BaseType {
-    _;
     static factory(type) {
-        return new OptionalType(type.schema, {
+        return new OptionalType(Optional(type.schema), {
             inner: type
         }, {
             ...type.params,
@@ -57,9 +53,8 @@ export class OptionalType extends BaseType {
     }
 }
 export class NullableType extends BaseType {
-    _;
     static factory(type) {
-        return new NullableType(type.schema, {
+        return new NullableType(Nullable(type.schema), {
             inner: type
         }, {
             ...type.params,
@@ -68,12 +63,8 @@ export class NullableType extends BaseType {
     }
 }
 export class DefaultType extends BaseType {
-    _;
     static factory(type, defaultValue) {
-        return new DefaultType({
-            ...type.schema,
-            default: defaultValue
-        }, {
+        return new DefaultType(Default(Optional(type.schema), defaultValue), {
             inner: type
         }, {
             ...type.params,

package/dist/types/base.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/base.ts"],"sourcesContent":["import {\n  Optional,\n  type SchemaOptions,\n  type StaticDecode,\n  type StaticEncode,\n  type TSchema,\n} from '@sinclair/typebox'\nimport {\n  Nullable,\n  type TNullable,\n  type TOptionalUndefined,\n} from '../schemas/nullable.ts'\nimport type { Merge } from '../utils.ts'\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeParams = {\n  optional?: boolean\n  nullable?: boolean\n  hasDefault?: boolean\n  encode?: (value: any) => any\n}\n\nexport type DefaultTypeParams = {\n  optional: false\n  nullable: false\n  hasDefault: false\n  encode?: TypeParams['encode']\n}\n\nexport type BaseTypeAny<T extends TSchema = TSchema> = BaseType<T, any, any>\n\ntype ResolveNullable<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['nullable'] extends true\n  ? T extends TNullable<infer S>\n    ? TNullable<S>\n    : TNullable<T>\n  : T\n\ntype ResolveOptional<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['optional'] extends true\n  ? T extends TOptionalUndefined<infer S>\n    ? TOptionalUndefined<S>\n    : TOptionalUndefined<T>\n  : T\n\ntype ResolveDefault<\n  T extends TSchema,\n  P extends TypeParams,\n> = P['hasDefault'] extends true\n  ? T extends TOptionalUndefined<infer U>\n    ? U\n    : T\n  : T\n\nexport abstract class BaseType<\n  Schema extends TSchema = TSchema,\n  Props extends TypeProps = TypeProps,\n  Params extends TypeParams = DefaultTypeParams,\n> {\n  abstract _: {\n    encoded: {\n      input: TSchema\n      output: TSchema\n    }\n    decoded: {\n      input: TSchema\n      output: TSchema\n    }\n  }\n\n  readonly schema: Schema\n  readonly final: TSchema\n  readonly props: Props\n  readonly params: Params\n\n  constructor(\n    schema: Schema,\n    props: Props = {} as Props,\n    params: Params = {} as Params,\n  ) {\n    const { hasDefault = false, nullable = false, optional = false } = params\n    this.schema = schema\n    this.final = schema\n    if (nullable) this.final = Nullable(this.final) as any\n    if (optional || hasDefault) this.final = Optional(this.final) as any\n\n    this.props = props\n    this.params = {\n      hasDefault,\n      nullable,\n      optional,\n    } as Params\n  }\n\n  optional(): OptionalType<this> {\n    return OptionalType.factory(this) as any\n  }\n\n  nullable(): NullableType<this> {\n    return NullableType.factory(this) as any\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(\n    value: StaticDecode<this['_']['decoded']['output']>,\n  ): DefaultType<this> {\n    return DefaultType.factory(\n      this,\n      this.params.encode?.(value) ?? value,\n    ) as any\n  }\n\n  description(description: string): this {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        description,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n\n  examples(...examples: any[]): this {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        examples,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n}\n\nexport type ConstantType<T extends TSchema> = {\n  encoded: {\n    input: T\n    output: T\n  }\n  decoded: {\n    input: T\n    output: T\n  }\n}\n\nexport type Static<\n  T extends BaseTypeAny,\n  P extends TypeProps,\n  Params extends Merge<T['params'], P> = Merge<T['params'], P>,\n> = {\n  encoded: {\n    input: ResolveOptional<\n      ResolveNullable<T['_']['encoded']['input'], Params>,\n      Params\n    >\n    output: ResolveDefault<\n      ResolveOptional<\n        ResolveNullable<T['_']['encoded']['output'], Params>,\n        Params\n      >,\n      Params\n    >\n  }\n  decoded: {\n    input: ResolveOptional<\n      ResolveNullable<T['_']['decoded']['input'], Params>,\n      Params\n    >\n    output: ResolveDefault<\n      ResolveOptional<\n        ResolveNullable<T['_']['decoded']['output'], Params>,\n        Params\n      >,\n      Params\n    >\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new OptionalType<T, Merge<T['params'], { optional: true }>>(\n      type.schema,\n      { inner: type },\n      { ...type.params, optional: true } as any,\n    )\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T, Merge<T['params'], { nullable: true }>>(\n      type.schema,\n      { inner: type },\n      { ...type.params, nullable: true } as any,\n    )\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny<any>,\n  Params extends TypeParams = DefaultTypeParams,\n> extends BaseType<Type['schema'], { inner: Type }, Params> {\n  _!: Static<Type, Params>\n\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T, Merge<T['params'], { hasDefault: true }>>(\n      { ...type.schema, default: defaultValue },\n      { inner: type },\n      { ...type.params, hasDefault: true } as any,\n    )\n  }\n}\n"],"names":["Optional","Nullable","BaseType","schema","final","props","params","constructor","hasDefault","nullable","optional","OptionalType","factory","NullableType","nullish","default","value","DefaultType","encode","description","ThisConstructor","examples","_","type","inner","defaultValue"],"mappings":"AAAA,SACEA,QAAQ,QAKH,oBAAmB;AAC1B,SACEC,QAAQ,QAGH,yBAAwB;AAgD/B,OAAO,MAAeC;IAgBXC,OAAc;IACdC,MAAc;IACdC,MAAY;IACZC,OAAc;IAEvBC,YACEJ,MAAc,EACdE,QAAe,CAAC,CAAU,EAC1BC,SAAiB,CAAC,CAAW,CAC7B;QACA,MAAM,EAAEE,aAAa,KAAK,EAAEC,WAAW,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGJ;QACnE,IAAI,CAACH,MAAM,GAAGA;QACd,IAAI,CAACC,KAAK,GAAGD;QACb,IAAIM,UAAU,IAAI,CAACL,KAAK,GAAGH,SAAS,IAAI,CAACG,KAAK;QAC9C,IAAIM,YAAYF,YAAY,IAAI,CAACJ,KAAK,GAAGJ,SAAS,IAAI,CAACI,KAAK;QAE5D,IAAI,CAACC,KAAK,GAAGA;QACb,IAAI,CAACC,MAAM,GAAG;YACZE;YACAC;YACAC;QACF;IACF;IAEAA,WAA+B;QAC7B,OAAOC,aAAaC,OAAO,CAAC,IAAI;IAClC;IAEAH,WAA+B;QAC7B,OAAOI,aAAaD,OAAO,CAAC,IAAI;IAClC;IAEAE,UAAU;QACR,OAAO,IAAI,CAACL,QAAQ,GAAGC,QAAQ;IACjC;IAEAK,QACEC,KAAmD,EAChC;QACnB,OAAOC,YAAYL,OAAO,CACxB,IAAI,EACJ,IAAI,CAACN,MAAM,CAACY,MAAM,GAAGF,UAAUA;IAEnC;IAEAG,YAAYA,WAAmB,EAAQ;QACrC,MAAMC,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAACjB,MAAM;YACdgB;QACF,GACA,IAAI,CAACd,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;IAEAe,SAAS,GAAGA,QAAe,EAAQ;QACjC,MAAMD,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAACjB,MAAM;YACdkB;QACF,GACA,IAAI,CAAChB,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;AACF;AA8CA,OAAO,MAAMK,qBAGHT;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAE;QAClD,OAAO,IAAIZ,aACTY,KAAKpB,MAAM,EACX;YAAEqB,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEI,UAAU;QAAK;IAErC;AACF;AAEA,OAAO,MAAMG,qBAGHX;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAE;QAClD,OAAO,IAAIV,aACTU,KAAKpB,MAAM,EACX;YAAEqB,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEG,UAAU;QAAK;IAErC;AACF;AAEA,OAAO,MAAMQ,oBAGHf;IACRoB,EAAwB;IAExB,OAAOV,QAAoCW,IAAO,EAAEE,YAAiB,EAAE;QACrE,OAAO,IAAIR,YACT;YAAE,GAAGM,KAAKpB,MAAM;YAAEY,SAASU;QAAa,GACxC;YAAED,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKjB,MAAM;YAAEE,YAAY;QAAK;IAEvC;AACF"}
+{"version":3,"sources":["../../../src/types/base.ts"],"sourcesContent":["import { Optional, type TOptional, type TSchema } from '@sinclair/typebox'\nimport { Default, type TDefault } from '../schemas/default.ts'\nimport { Nullable, type TNullable } from '../schemas/nullable.ts'\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeParams = {\n  optional?: boolean\n  nullable?: boolean\n  hasDefault?: boolean\n  encode?: (value: any) => any\n}\n\nexport type DefaultTypeParams = {\n  optional: false\n  nullable: false\n  hasDefault: false\n  encode?: TypeParams['encode']\n}\n\nexport type BaseTypeAny<T extends TSchema = TSchema> = BaseType<\n  T,\n  TypeProps,\n  any\n>\n\nexport abstract class BaseType<\n  Schema extends TSchema = TSchema,\n  Props extends TypeProps = TypeProps,\n  ValueType = unknown,\n> {\n  readonly schema: Schema\n  readonly props: Props\n  readonly params: TypeParams\n\n  constructor(\n    schema: Schema,\n    props: Props = {} as Props,\n    params: TypeParams = {} as TypeParams,\n  ) {\n    const { hasDefault = false, nullable = false, optional = false } = params\n    this.schema = schema\n\n    this.props = props\n    this.params = {\n      hasDefault,\n      nullable,\n      optional,\n    } as TypeParams\n  }\n\n  optional(): OptionalType<BaseType<Schema, Props>, ValueType> {\n    return OptionalType.factory(this) as any\n  }\n\n  nullable(): NullableType<BaseType<Schema, Props>, ValueType> {\n    return NullableType.factory(this) as any\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(value: ValueType): DefaultType<BaseType<Schema, Props>, ValueType> {\n    return DefaultType.factory(\n      this,\n      this.params.encode?.(value) ?? value,\n    ) as any\n  }\n\n  description(description: string): BaseType<Schema, Props, ValueType> {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        description,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n\n  examples(...examples: ValueType[]): BaseType<Schema, Props, ValueType> {\n    const ThisConstructor = this.constructor as any\n    return new ThisConstructor(\n      {\n        ...this.schema,\n        examples,\n      },\n      this.props,\n      this.params,\n    ) as any\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny = BaseTypeAny,\n  ValueType = unknown,\n> extends BaseType<TOptional<Type['schema']>, { inner: Type }, ValueType> {\n  static factory<T extends BaseTypeAny>(type: T) {\n    return new OptionalType<T>(Optional(type.schema) as any, { inner: type }, {\n      ...type.params,\n      optional: true,\n    } as any)\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any> = BaseTypeAny<any>,\n  ValueType = unknown,\n> extends BaseType<\n  TNullable<Type['schema']>,\n  { inner: Type },\n  ValueType | null\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T>(Nullable(type.schema), { inner: type }, {\n      ...type.params,\n      nullable: true,\n    } as any)\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny = BaseTypeAny,\n  ValueType = unknown,\n> extends BaseType<\n  TDefault<TOptional<Type['schema']>>,\n  { inner: Type },\n  ValueType\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T>(\n      Default(Optional(type.schema), defaultValue) as any,\n      { inner: type },\n      { ...type.params, hasDefault: true } as any,\n    )\n  }\n}\n"],"names":["Optional","Default","Nullable","BaseType","schema","props","params","constructor","hasDefault","nullable","optional","OptionalType","factory","NullableType","nullish","default","value","DefaultType","encode","description","ThisConstructor","examples","type","inner","defaultValue"],"mappings":"AAAA,SAASA,QAAQ,QAAsC,oBAAmB;AAC1E,SAASC,OAAO,QAAuB,wBAAuB;AAC9D,SAASC,QAAQ,QAAwB,yBAAwB;AAwBjE,OAAO,MAAeC;IAKXC,OAAc;IACdC,MAAY;IACZC,OAAkB;IAE3BC,YACEH,MAAc,EACdC,QAAe,CAAC,CAAU,EAC1BC,SAAqB,CAAC,CAAe,CACrC;QACA,MAAM,EAAEE,aAAa,KAAK,EAAEC,WAAW,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGJ;QACnE,IAAI,CAACF,MAAM,GAAGA;QAEd,IAAI,CAACC,KAAK,GAAGA;QACb,IAAI,CAACC,MAAM,GAAG;YACZE;YACAC;YACAC;QACF;IACF;IAEAA,WAA6D;QAC3D,OAAOC,aAAaC,OAAO,CAAC,IAAI;IAClC;IAEAH,WAA6D;QAC3D,OAAOI,aAAaD,OAAO,CAAC,IAAI;IAClC;IAEAE,UAAU;QACR,OAAO,IAAI,CAACL,QAAQ,GAAGC,QAAQ;IACjC;IAEAK,QAAQC,KAAgB,EAAmD;QACzE,OAAOC,YAAYL,OAAO,CACxB,IAAI,EACJ,IAAI,CAACN,MAAM,CAACY,MAAM,GAAGF,UAAUA;IAEnC;IAEAG,YAAYA,WAAmB,EAAsC;QACnE,MAAMC,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAAChB,MAAM;YACde;QACF,GACA,IAAI,CAACd,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;IAEAe,SAAS,GAAGA,QAAqB,EAAsC;QACrE,MAAMD,kBAAkB,IAAI,CAACb,WAAW;QACxC,OAAO,IAAIa,gBACT;YACE,GAAG,IAAI,CAAChB,MAAM;YACdiB;QACF,GACA,IAAI,CAAChB,KAAK,EACV,IAAI,CAACC,MAAM;IAEf;AACF;AAEA,OAAO,MAAMK,qBAGHR;IACR,OAAOS,QAA+BU,IAAO,EAAE;QAC7C,OAAO,IAAIX,aAAgBX,SAASsB,KAAKlB,MAAM,GAAU;YAAEmB,OAAOD;QAAK,GAAG;YACxE,GAAGA,KAAKhB,MAAM;YACdI,UAAU;QACZ;IACF;AACF;AAEA,OAAO,MAAMG,qBAGHV;IAKR,OAAOS,QAAoCU,IAAO,EAAE;QAClD,OAAO,IAAIT,aAAgBX,SAASoB,KAAKlB,MAAM,GAAG;YAAEmB,OAAOD;QAAK,GAAG;YACjE,GAAGA,KAAKhB,MAAM;YACdG,UAAU;QACZ;IACF;AACF;AAEA,OAAO,MAAMQ,oBAGHd;IAKR,OAAOS,QAAoCU,IAAO,EAAEE,YAAiB,EAAE;QACrE,OAAO,IAAIP,YACThB,QAAQD,SAASsB,KAAKlB,MAAM,GAAGoB,eAC/B;YAAED,OAAOD;QAAK,GACd;YAAE,GAAGA,KAAKhB,MAAM;YAAEE,YAAY;QAAK;IAEvC;AACF"}

package/dist/types/boolean.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class BooleanType extends BaseType {
-    _;
     static factory() {
         return new BooleanType(Type.Boolean());
     }

package/dist/types/boolean.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/boolean.ts"],"sourcesContent":["import {\n  type SchemaOptions,\n  type StaticDecode,\n  type TBoolean,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class BooleanType extends BaseType<TBoolean> {\n  _!: ConstantType<this['schema']>\n\n  static factory() {\n    return new BooleanType(Type.Boolean())\n  }\n}\n"],"names":["Type","BaseType","BooleanType","_","factory","Boolean"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,oBAAoBD;IAC/BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,YAAYF,KAAKK,OAAO;IACrC;AACF"}
+{"version":3,"sources":["../../../src/types/boolean.ts"],"sourcesContent":["import { type TBoolean, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType extends BaseType<TBoolean, {}, boolean> {\n  static factory() {\n    return new BooleanType(Type.Boolean())\n  }\n}\n"],"names":["Type","BaseType","BooleanType","factory","Boolean"],"mappings":"AAAA,SAAwBA,IAAI,QAAQ,oBAAmB;AACvD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,oBAAoBD;IAC/B,OAAOE,UAAU;QACf,OAAO,IAAID,YAAYF,KAAKI,OAAO;IACrC;AACF"}

package/dist/types/custom.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class TransformType extends BaseType {
-    _;
 }
 export class CustomType extends TransformType {
     static factory(decode, encode, schema = Type.Any()) {

package/dist/types/custom.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/custom.ts"],"sourcesContent":["import {\n  type TAny,\n  type TTransform,\n  type TUnsafe,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport type CustomTypeDecode<T> = (value: any) => T\nexport type CustomTypeEncode<T> = (value: T) => any\n\nexport abstract class TransformType<T, S = TAny> extends BaseType<\n  TTransform<TUnsafe<S>, T>\n> {\n  _!: ConstantType<this['schema']>\n}\n\nexport class CustomType<T, S = TAny> extends TransformType<T, S> {\n  static factory<T, S = TAny>(\n    decode: CustomTypeDecode<T>,\n    encode: CustomTypeEncode<T>,\n    schema = Type.Any() as unknown as TUnsafe<S>,\n  ) {\n    return new CustomType<T, S>(\n      Type.Transform(schema as unknown as TUnsafe<S>)\n        .Decode(decode)\n        .Encode(encode),\n      {},\n      { encode } as any,\n    )\n  }\n}\n"],"names":["Type","BaseType","TransformType","_","CustomType","factory","decode","encode","schema","Any","Transform","Decode","Encode"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAKvD,OAAO,MAAeC,sBAAmCD;IAGvDE,EAAgC;AAClC;AAEA,OAAO,MAAMC,mBAAgCF;IAC3C,OAAOG,QACLC,MAA2B,EAC3BC,MAA2B,EAC3BC,SAASR,KAAKS,GAAG,EAA2B,EAC5C;QACA,OAAO,IAAIL,WACTJ,KAAKU,SAAS,CAACF,QACZG,MAAM,CAACL,QACPM,MAAM,CAACL,SACV,CAAC,GACD;YAAEA;QAAO;IAEb;AACF"}
+{"version":3,"sources":["../../../src/types/custom.ts"],"sourcesContent":["import {\n  type TAny,\n  type TSchema,\n  type TTransform,\n  Type,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode, StaticOutputDecode } from '../inference.ts'\nimport { BaseType } from './base.ts'\n\nexport type CustomTypeDecode<T> = (value: any) => T\nexport type CustomTypeEncode<T> = (value: T) => any\n\nexport abstract class TransformType<\n  T,\n  S extends TSchema = TAny,\n> extends BaseType<TTransform<S, T>, {}, StaticInputDecode<TTransform<S, T>>> {}\n\nexport class CustomType<T, S extends TSchema = TAny> extends TransformType<\n  T,\n  S\n> {\n  static factory<T, S extends TSchema = TAny>(\n    decode: CustomTypeDecode<T>,\n    encode: CustomTypeEncode<T>,\n    schema: S = Type.Any() as S,\n  ) {\n    return new CustomType<T, S>(\n      Type.Transform(schema).Decode(decode).Encode(encode),\n      {},\n      { encode } as any,\n    )\n  }\n}\n"],"names":["Type","BaseType","TransformType","CustomType","factory","decode","encode","schema","Any","Transform","Decode","Encode"],"mappings":"AAAA,SAIEA,IAAI,QACC,oBAAmB;AAE1B,SAASC,QAAQ,QAAQ,YAAW;AAKpC,OAAO,MAAeC,sBAGZD;AAAqE;AAE/E,OAAO,MAAME,mBAAgDD;IAI3D,OAAOE,QACLC,MAA2B,EAC3BC,MAA2B,EAC3BC,SAAYP,KAAKQ,GAAG,EAAO,EAC3B;QACA,OAAO,IAAIL,WACTH,KAAKS,SAAS,CAACF,QAAQG,MAAM,CAACL,QAAQM,MAAM,CAACL,SAC7C,CAAC,GACD;YAAEA;QAAO;IAEb;AACF"}

package/dist/types/date.js

@@ -1,8 +1,16 @@
+import { Type } from '@sinclair/typebox';
 import { CustomType, TransformType } from "./custom.js";
 const decode = (value)=>new Date(value);
 const encode = (value)=>value.toISOString();
 export class DateType extends TransformType {
     static factory() {
-        return CustomType.factory(decode, encode);
+        return CustomType.factory(decode, encode, Type.Union([
+            Type.String({
+                format: 'date'
+            }),
+            Type.String({
+                format: 'date-time'
+            })
+        ]));
     }
 }

package/dist/types/date.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/date.ts"],"sourcesContent":["import { CustomType, TransformType } from './custom.ts'\n\nconst decode = (value: any): Date => new Date(value)\nconst encode = (value: Date): any => value.toISOString()\n\nexport class DateType extends TransformType<Date> {\n  static factory() {\n    return CustomType.factory<Date>(decode, encode)\n  }\n}\n"],"names":["CustomType","TransformType","decode","value","Date","encode","toISOString","DateType","factory"],"mappings":"AAAA,SAASA,UAAU,EAAEC,aAAa,QAAQ,cAAa;AAEvD,MAAMC,SAAS,CAACC,QAAqB,IAAIC,KAAKD;AAC9C,MAAME,SAAS,CAACF,QAAqBA,MAAMG,WAAW;AAEtD,OAAO,MAAMC,iBAAiBN;IAC5B,OAAOO,UAAU;QACf,OAAOR,WAAWQ,OAAO,CAAON,QAAQG;IAC1C;AACF"}
+{"version":3,"sources":["../../../src/types/date.ts"],"sourcesContent":["import { type TString, Type } from '@sinclair/typebox'\nimport { CustomType, TransformType } from './custom.ts'\n\nconst decode = (value: any): Date => new Date(value)\nconst encode = (value: Date): any => value.toISOString()\n\nexport class DateType extends TransformType<Date> {\n  static factory() {\n    return CustomType.factory<Date, TString>(\n      decode,\n      encode,\n      Type.Union([\n        Type.String({\n          format: 'date',\n        }),\n        Type.String({\n          format: 'date-time',\n        }),\n      ]) as unknown as TString,\n    )\n  }\n}\n"],"names":["Type","CustomType","TransformType","decode","value","Date","encode","toISOString","DateType","factory","Union","String","format"],"mappings":"AAAA,SAAuBA,IAAI,QAAQ,oBAAmB;AACtD,SAASC,UAAU,EAAEC,aAAa,QAAQ,cAAa;AAEvD,MAAMC,SAAS,CAACC,QAAqB,IAAIC,KAAKD;AAC9C,MAAME,SAAS,CAACF,QAAqBA,MAAMG,WAAW;AAEtD,OAAO,MAAMC,iBAAiBN;IAC5B,OAAOO,UAAU;QACf,OAAOR,WAAWQ,OAAO,CACvBN,QACAG,QACAN,KAAKU,KAAK,CAAC;YACTV,KAAKW,MAAM,CAAC;gBACVC,QAAQ;YACV;YACAZ,KAAKW,MAAM,CAAC;gBACVC,QAAQ;YACV;SACD;IAEL;AACF"}

package/dist/types/enum.js

@@ -1,17 +1,19 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class ObjectEnumType extends BaseType {
-    _;
     static factory(values) {
-        return new ObjectEnumType(Type.Enum(values));
+        return new ObjectEnumType(Type.Enum(values), {
+            values: Object.values(values)
+        });
     }
 }
 export class EnumType extends BaseType {
-    _;
     static factory(values) {
         return new EnumType(Type.Enum(Object.fromEntries(values.map((v)=>[
                 v,
                 v
-            ]))));
+            ]))), {
+            values
+        });
     }
 }

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import {\n  Enum,\n  type SchemaOptions,\n  type StaticDecode,\n  type TEnum,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class ObjectEnumType<\n  T extends { [K in string]: K } = { [K in string]: K },\n> extends BaseType<TEnum<T>> {\n  _!: ConstantType<this['schema']>\n\n  static factory<T extends { [K in string]: K }>(values: T) {\n    return new ObjectEnumType<T>(Type.Enum(values as any))\n  }\n}\n\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n> extends BaseType<TEnum<Record<string, T[number]>>> {\n  _!: ConstantType<this['schema']>\n\n  static factory<T extends (string | number)[]>(values: [...T]) {\n    return new EnumType<T>(\n      Type.Enum(Object.fromEntries(values.map((v) => [v, v])) as any),\n    )\n  }\n}\n"],"names":["Type","BaseType","ObjectEnumType","_","factory","values","Enum","EnumType","Object","fromEntries","map","v"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,uBAEHD;IACRE,EAAgC;IAEhC,OAAOC,QAAwCC,MAAS,EAAE;QACxD,OAAO,IAAIH,eAAkBF,KAAKM,IAAI,CAACD;IACzC;AACF;AAEA,OAAO,MAAME,iBAEHN;IACRE,EAAgC;IAEhC,OAAOC,QAAuCC,MAAc,EAAE;QAC5D,OAAO,IAAIE,SACTP,KAAKM,IAAI,CAACE,OAAOC,WAAW,CAACJ,OAAOK,GAAG,CAAC,CAACC,IAAM;gBAACA;gBAAGA;aAAE;IAEzD;AACF"}
+{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import { type TEnum, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class ObjectEnumType<\n  T extends { [K in string]: K } = { [K in string]: K },\n> extends BaseType<TEnum<T>, { values: T[keyof T] }, T[keyof T]> {\n  static factory<T extends { [K in string]: K }>(values: T) {\n    return new ObjectEnumType<T>(Type.Enum(values as any), {\n      values: Object.values(values) as unknown as T[keyof T],\n    })\n  }\n}\n\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n> extends BaseType<\n  TEnum<Record<string, T[number]>>,\n  { values: [...T] },\n  T[keyof T]\n> {\n  static factory<T extends (string | number)[]>(values: [...T]) {\n    return new EnumType<T>(\n      Type.Enum(Object.fromEntries(values.map((v) => [v, v])) as any),\n      { values },\n    )\n  }\n}\n"],"names":["Type","BaseType","ObjectEnumType","factory","values","Enum","Object","EnumType","fromEntries","map","v"],"mappings":"AAAA,SAAqBA,IAAI,QAAQ,oBAAmB;AACpD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,uBAEHD;IACR,OAAOE,QAAwCC,MAAS,EAAE;QACxD,OAAO,IAAIF,eAAkBF,KAAKK,IAAI,CAACD,SAAgB;YACrDA,QAAQE,OAAOF,MAAM,CAACA;QACxB;IACF;AACF;AAEA,OAAO,MAAMG,iBAEHN;IAKR,OAAOE,QAAuCC,MAAc,EAAE;QAC5D,OAAO,IAAIG,SACTP,KAAKK,IAAI,CAACC,OAAOE,WAAW,CAACJ,OAAOK,GAAG,CAAC,CAACC,IAAM;gBAACA;gBAAGA;aAAE,KACrD;YAAEN;QAAO;IAEb;AACF"}

package/dist/types/literal.js

@@ -1,8 +1,9 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
-    _;
     static factory(value) {
-        return new LiteralType(Type.Literal(value));
+        return new LiteralType(Type.Literal(value), {
+            value
+        });
     }
 }

package/dist/types/literal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/literal.ts"],"sourcesContent":["import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class LiteralType<\n  T extends TLiteralValue = TLiteralValue,\n> extends BaseType<TLiteral<T>> {\n  _!: ConstantType<this['schema']>\n\n  static factory<T extends TLiteralValue>(value: T) {\n    return new LiteralType<T>(Type.Literal(value))\n  }\n}\n"],"names":["Type","BaseType","LiteralType","_","factory","value","Literal"],"mappings":"AAAA,SAA4CA,IAAI,QAAQ,oBAAmB;AAC3E,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,oBAEHD;IACRE,EAAgC;IAEhC,OAAOC,QAAiCC,KAAQ,EAAE;QAChD,OAAO,IAAIH,YAAeF,KAAKM,OAAO,CAACD;IACzC;AACF"}
+{"version":3,"sources":["../../../src/types/literal.ts"],"sourcesContent":["import { type TLiteral, type TLiteralValue, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class LiteralType<\n  T extends TLiteralValue = TLiteralValue,\n> extends BaseType<TLiteral<T>, { value: TLiteralValue }, T> {\n  static factory<T extends TLiteralValue>(value: T) {\n    return new LiteralType<T>(Type.Literal(value), { value })\n  }\n}\n"],"names":["Type","BaseType","LiteralType","factory","value","Literal"],"mappings":"AAAA,SAA4CA,IAAI,QAAQ,oBAAmB;AAC3E,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,oBAEHD;IACR,OAAOE,QAAiCC,KAAQ,EAAE;QAChD,OAAO,IAAIF,YAAeF,KAAKK,OAAO,CAACD,QAAQ;YAAEA;QAAM;IACzD;AACF"}

package/dist/types/never.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class NeverType extends BaseType {
-    _;
     static factory() {
         return new NeverType(Type.Never());
     }

package/dist/types/never.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/never.ts"],"sourcesContent":["import { type TNever, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\n\nexport class NeverType extends BaseType<TNever> {\n  _!: ConstantType<this['schema']>\n\n  static factory() {\n    return new NeverType(Type.Never())\n  }\n}\n"],"names":["Type","BaseType","NeverType","_","factory","Never"],"mappings":"AAAA,SAAsBA,IAAI,QAAQ,oBAAmB;AACrD,SAASC,QAAQ,QAA2B,YAAW;AAEvD,OAAO,MAAMC,kBAAkBD;IAC7BE,EAAgC;IAEhC,OAAOC,UAAU;QACf,OAAO,IAAIF,UAAUF,KAAKK,KAAK;IACjC;AACF"}
+{"version":3,"sources":["../../../src/types/never.ts"],"sourcesContent":["import { type TNever, Type } from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class NeverType extends BaseType<TNever, {}, never> {\n  static factory() {\n    return new NeverType(Type.Never())\n  }\n}\n"],"names":["Type","BaseType","NeverType","factory","Never"],"mappings":"AAAA,SAAsBA,IAAI,QAAQ,oBAAmB;AACrD,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,kBAAkBD;IAC7B,OAAOE,UAAU;QACf,OAAO,IAAID,UAAUF,KAAKI,KAAK;IACjC;AACF"}

package/dist/types/number.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class NumberType extends BaseType {
-    _;
     static factory(options = {}) {
         return new NumberType(Type.Number(options), {
             options
@@ -33,7 +32,6 @@ export class NumberType extends BaseType {
     }
 }
 export class IntegerType extends BaseType {
-    _;
     static factory(options = {}) {
         return new IntegerType(Type.Integer(options), {
             options
@@ -65,10 +63,11 @@ export class IntegerType extends BaseType {
     }
 }
 export class BigIntType extends BaseType {
-    _;
     static factory(options = {}) {
         return new BigIntType(Type.BigInt(options), {
             options
+        }, {
+            encode: (value)=>`${value}`
         });
     }
     positive() {

package/dist/types/number.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/number.ts"],"sourcesContent":["import {\n  type BigIntOptions,\n  type IntegerOptions,\n  type NumberOptions,\n  type Static,\n  type StaticDecode,\n  type StringOptions,\n  type TBigInt,\n  type TInteger,\n  type TNumber,\n  type TString,\n  type TTransform,\n  Type,\n  TypeBoxError,\n} from '@sinclair/typebox'\nimport { BaseType, type ConstantType } from './base.ts'\nimport { CustomType, TransformType } from './custom.ts'\n\nexport class NumberType extends BaseType<TNumber, { options: NumberOptions }> {\n  _!: ConstantType<this['schema']>\n\n  static factory(options: NumberOptions = {}) {\n    return new NumberType(Type.Number(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\nexport class IntegerType extends BaseType<\n  TInteger,\n  { options: IntegerOptions }\n> {\n  _!: ConstantType<this['schema']>\n\n  static factory(options: IntegerOptions = {}) {\n    return new IntegerType(Type.Integer(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\n// TODO: this is not json schema compatible\nexport class BigIntType extends BaseType<TBigInt, { options: BigIntOptions }> {\n  _!: ConstantType<this['schema']>\n\n  static factory(options: BigIntOptions = {}) {\n    return new BigIntType(Type.BigInt(options), { options })\n  }\n\n  positive() {\n    return this.min(0n, true)\n  }\n\n  negative() {\n    return this.max(0n, true)\n  }\n\n  max(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n"],"names":["Type","BaseType","NumberType","_","factory","options","Number","positive","min","negative","max","value","exclusive","props","maximum","exclusiveMaximum","minimum","exclusiveMinimum","IntegerType","Integer","BigIntType","BigInt"],"mappings":"AAAA,SAYEA,IAAI,QAEC,oBAAmB;AAC1B,SAASC,QAAQ,QAA2B,YAAW;AAGvD,OAAO,MAAMC,mBAAmBD;IAC9BE,EAAgC;IAEhC,OAAOC,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIH,WAAWF,KAAKM,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOV,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOV,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAEA,OAAO,MAAMO,oBAAoBjB;IAI/BE,EAAgC;IAEhC,OAAOC,QAAQC,UAA0B,CAAC,CAAC,EAAE;QAC3C,OAAO,IAAIa,YAAYlB,KAAKmB,OAAO,CAACd,UAAU;YAAEA;QAAQ;IAC1D;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAGA,OAAO,MAAMS,mBAAmBnB;IAC9BE,EAAgC;IAEhC,OAAOC,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIe,WAAWpB,KAAKqB,MAAM,CAAChB,UAAU;YAAEA;QAAQ;IACxD;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF"}
+{"version":3,"sources":["../../../src/types/number.ts"],"sourcesContent":["import {\n  type BigIntOptions,\n  type IntegerOptions,\n  type NumberOptions,\n  type TBigInt,\n  type TInteger,\n  type TNumber,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType } from './base.ts'\n\nexport class NumberType extends BaseType<\n  TNumber,\n  { options: NumberOptions },\n  number\n> {\n  static factory(options: NumberOptions = {}) {\n    return new NumberType(Type.Number(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return NumberType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\nexport class IntegerType extends BaseType<\n  TInteger,\n  { options: IntegerOptions },\n  number\n> {\n  static factory(options: IntegerOptions = {}) {\n    return new IntegerType(Type.Integer(options), { options })\n  }\n\n  positive() {\n    return this.min(0, true)\n  }\n\n  negative() {\n    return this.max(0, true)\n  }\n\n  max(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: number, exclusive?: true) {\n    return IntegerType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n\n// TODO: this is not json schema compatible\nexport class BigIntType extends BaseType<\n  TBigInt,\n  { options: BigIntOptions },\n  bigint\n> {\n  static factory(options: BigIntOptions = {}) {\n    return new BigIntType(\n      Type.BigInt(options),\n      { options },\n      { encode: (value) => `${value}` },\n    )\n  }\n\n  positive() {\n    return this.min(0n, true)\n  }\n\n  negative() {\n    return this.max(0n, true)\n  }\n\n  max(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      maximum: value,\n      ...(!exclusive ? {} : { exclusiveMaximum: value }),\n    })\n  }\n\n  min(value: bigint, exclusive?: true) {\n    return BigIntType.factory({\n      ...this.props.options,\n      minimum: value,\n      ...(!exclusive ? {} : { exclusiveMinimum: value }),\n    })\n  }\n}\n"],"names":["Type","BaseType","NumberType","factory","options","Number","positive","min","negative","max","value","exclusive","props","maximum","exclusiveMaximum","minimum","exclusiveMinimum","IntegerType","Integer","BigIntType","BigInt","encode"],"mappings":"AAAA,SAOEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,mBAAmBD;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIF,WAAWF,KAAKK,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOT,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOT,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAEA,OAAO,MAAMO,oBAAoBhB;IAK/B,OAAOE,QAAQC,UAA0B,CAAC,CAAC,EAAE;QAC3C,OAAO,IAAIa,YAAYjB,KAAKkB,OAAO,CAACd,UAAU;YAAEA;QAAQ;IAC1D;IAEAE,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,GAAG;IACrB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOM,YAAYd,OAAO,CAAC;YACzB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF;AAGA,OAAO,MAAMS,mBAAmBlB;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIe,WACTnB,KAAKoB,MAAM,CAAChB,UACZ;YAAEA;QAAQ,GACV;YAAEiB,QAAQ,CAACX,QAAU,CAAC,EAAEA,MAAM,CAAC;QAAC;IAEpC;IAEAJ,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAC,WAAW;QACT,OAAO,IAAI,CAACC,GAAG,CAAC,EAAE,EAAE;IACtB;IAEAA,IAAIC,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBS,SAASH;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEG,kBAAkBJ;YAAM,CAAC;QACnD;IACF;IAEAH,IAAIG,KAAa,EAAEC,SAAgB,EAAE;QACnC,OAAOQ,WAAWhB,OAAO,CAAC;YACxB,GAAG,IAAI,CAACS,KAAK,CAACR,OAAO;YACrBW,SAASL;YACT,GAAI,CAACC,YAAY,CAAC,IAAI;gBAAEK,kBAAkBN;YAAM,CAAC;QACnD;IACF;AACF"}

package/dist/types/object.js

@@ -1,5 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
+import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
     static factory(properties, options = {}) {
         const schemaProperties = {};
@@ -12,8 +13,37 @@ export class ObjectType extends BaseType {
     }
 }
 export class RecordType extends BaseType {
-    _;
     static factory(key, element, options = {}) {
         return new RecordType(Type.Record(key.schema, element.schema, options));
     }
 }
+export function keyof(type) {
+    return EnumType.factory(Object.keys(type.props.properties));
+}
+export function pick(source, pick) {
+    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>pick[key]));
+    return ObjectType.factory(properties);
+}
+export function omit(source, omit) {
+    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key])=>!omit[key]));
+    return ObjectType.factory(properties);
+}
+export function extend(object1, properties) {
+    return ObjectType.factory({
+        ...object1.props.properties,
+        ...properties
+    });
+}
+export function merge(object1, object2) {
+    return ObjectType.factory({
+        ...object1.props.properties,
+        ...object2.props.properties
+    });
+}
+export function partial(object) {
+    const properties = {};
+    for (const [key, value] of Object.entries(object.props.properties)){
+        properties[key] = value.optional();
+    }
+    return ObjectType.factory(properties, {});
+}

package/dist/types/object.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecordOrObject,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { EnumType, ObjectEnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny<any> }\nexport class ObjectType<\n  T extends ObjectTypeProps = ObjectTypeProps,\n> extends BaseType<\n  TObject<{ [K in keyof T]: T[K]['schema'] }>,\n  { properties: T }\n> {\n  declare _: {\n    encoded: {\n      input: TObject<{ [K in keyof T]: T[K]['_']['encoded']['input'] }>\n      output: TObject<{ [K in keyof T]: T[K]['_']['encoded']['output'] }>\n    }\n    decoded: {\n      input: TObject<{ [K in keyof T]: T[K]['_']['decoded']['input'] }>\n      output: TObject<{ [K in keyof T]: T[K]['_']['decoded']['output'] }>\n    }\n  }\n\n  static factory<T extends ObjectTypeProps = ObjectTypeProps>(\n    properties: T,\n    options: ObjectOptions = {},\n  ) {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K]['schema']\n    }\n\n    for (const key in properties) {\n      schemaProperties[key] = properties[key].schema\n    }\n\n    return new ObjectType<T>(Type.Object(schemaProperties, options) as any, {\n      properties,\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType | EnumType | ObjectEnumType | StringType,\n  E extends BaseType,\n> extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {\n  _!: {\n    encoded: {\n      input: TRecordOrObject<\n        K['_']['encoded']['input'],\n        E['_']['encoded']['input']\n      >\n      output: TRecordOrObject<\n        K['_']['encoded']['output'],\n        E['_']['encoded']['output']\n      >\n    }\n    decoded: {\n      input: TRecordOrObject<\n        K['_']['decoded']['input'],\n        E['_']['decoded']['input']\n      >\n      output: TRecordOrObject<\n        K['_']['decoded']['output'],\n        E['_']['decoded']['output']\n      >\n    }\n  }\n\n  static factory<\n    K extends\n      | LiteralType<any>\n      | EnumType<any>\n      | ObjectEnumType<any>\n      | StringType,\n    E extends BaseType,\n  >(key: K, element: E, options: ObjectOptions = {}) {\n    return new RecordType<K, E>(\n      Type.Record(key.schema, element.schema, options) as any,\n    )\n  }\n}\n"],"names":["Type","BaseType","ObjectType","factory","properties","options","schemaProperties","key","schema","Object","RecordType","_","element","Record"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAC1B,SAASC,QAAQ,QAA0B,YAAW;AAMtD,OAAO,MAAMC,mBAEHD;IAeR,OAAOE,QACLC,UAAa,EACbC,UAAyB,CAAC,CAAC,EAC3B;QACA,MAAMC,mBAAmB,CAAC;QAI1B,IAAK,MAAMC,OAAOH,WAAY;YAC5BE,gBAAgB,CAACC,IAAI,GAAGH,UAAU,CAACG,IAAI,CAACC,MAAM;QAChD;QAEA,OAAO,IAAIN,WAAcF,KAAKS,MAAM,CAACH,kBAAkBD,UAAiB;YACtED;QACF;IACF;AACF;AAEA,OAAO,MAAMM,mBAGHT;IACRU,EAqBC;IAED,OAAOR,QAOLI,GAAM,EAAEK,OAAU,EAAEP,UAAyB,CAAC,CAAC,EAAE;QACjD,OAAO,IAAIK,WACTV,KAAKa,MAAM,CAACN,IAAIC,MAAM,EAAEI,QAAQJ,MAAM,EAAEH;IAE5C;AACF"}
+{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecordOrObject,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode } from '../inference.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'\nimport { EnumType, type ObjectEnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny }\nexport type AnyObjectType = ObjectType<ObjectTypeProps>\nexport class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<\n  TObject<{ [K in keyof T]: T[K]['schema'] }>,\n  { properties: T },\n  StaticInputDecode<TObject<{ [K in keyof T]: T[K]['schema'] }>>\n> {\n  static factory<T extends ObjectTypeProps = {}>(\n    properties: T,\n    options: ObjectOptions = {},\n  ) {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K]['schema']\n    }\n\n    for (const key in properties) {\n      schemaProperties[key] = properties[key].schema\n    }\n\n    return new ObjectType<T>(Type.Object(schemaProperties, options) as any, {\n      properties,\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType | EnumType | ObjectEnumType | StringType,\n  E extends BaseType,\n> extends BaseType<TRecordOrObject<K['schema'], E['schema']>> {\n  static factory<\n    K extends\n      | LiteralType<any>\n      | EnumType<any>\n      | ObjectEnumType<any>\n      | StringType,\n    E extends BaseType,\n  >(key: K, element: E, options: ObjectOptions = {}) {\n    return new RecordType<K, E>(\n      Type.Record(key.schema, element.schema, options) as any,\n    )\n  }\n}\n\nexport function keyof<T extends ObjectType>(\n  type: T,\n): EnumType<\n  UnionToTupleString<T extends ObjectType<infer Props> ? keyof Props : never>\n> {\n  return EnumType.factory(Object.keys(type.props.properties) as any)\n}\n\nexport function pick<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  pick: P,\n): ObjectType<{\n  [K in keyof P]: P[K] extends true\n    ? K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n    : never\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => pick[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function omit<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  omit: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] as K extends keyof P\n    ? never\n    : K]: T['props']['properties'][K]\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function extend<T extends AnyObjectType, P extends ObjectTypeProps>(\n  object1: T,\n  properties: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n    ? P[K]\n    : K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...properties,\n  }) as any\n}\n\nexport function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(\n  object1: T1,\n  object2: T2,\n): ObjectType<{\n  [K in\n    | keyof T1['props']['properties']\n    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n    ? T2['props']['properties'][K]\n    : K extends keyof T1['props']['properties']\n      ? T1['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...object2.props.properties,\n  }) as any\n}\n\nexport function partial<\n  T extends AnyObjectType,\n  P extends T extends ObjectType<infer Props> ? Props : never,\n>(\n  object: T,\n): ObjectType<{\n  [K in keyof P]: P[K] extends BaseType<any, any, infer T>\n    ? OptionalType<P[K], T>\n    : never\n}> {\n  const properties = {} as any\n\n  for (const [key, value] of Object.entries(object.props.properties)) {\n    properties[key] = value.optional()\n  }\n\n  return ObjectType.factory(properties, {}) as any\n}\n"],"names":["Type","BaseType","EnumType","ObjectType","factory","properties","options","schemaProperties","key","schema","Object","RecordType","element","Record","keyof","type","keys","props","pick","source","fromEntries","entries","filter","omit","extend","object1","merge","object2","partial","object","value","optional"],"mappings":"AAAA,SAKEA,IAAI,QACC,oBAAmB;AAG1B,SAASC,QAAQ,QAA6C,YAAW;AACzE,SAASC,QAAQ,QAA6B,YAAW;AAMzD,OAAO,MAAMC,mBAAmDF;IAK9D,OAAOG,QACLC,UAAa,EACbC,UAAyB,CAAC,CAAC,EAC3B;QACA,MAAMC,mBAAmB,CAAC;QAI1B,IAAK,MAAMC,OAAOH,WAAY;YAC5BE,gBAAgB,CAACC,IAAI,GAAGH,UAAU,CAACG,IAAI,CAACC,MAAM;QAChD;QAEA,OAAO,IAAIN,WAAcH,KAAKU,MAAM,CAACH,kBAAkBD,UAAiB;YACtED;QACF;IACF;AACF;AAEA,OAAO,MAAMM,mBAGHV;IACR,OAAOG,QAOLI,GAAM,EAAEI,OAAU,EAAEN,UAAyB,CAAC,CAAC,EAAE;QACjD,OAAO,IAAIK,WACTX,KAAKa,MAAM,CAACL,IAAIC,MAAM,EAAEG,QAAQH,MAAM,EAAEH;IAE5C;AACF;AAEA,OAAO,SAASQ,MACdC,IAAO;IAIP,OAAOb,SAASE,OAAO,CAACM,OAAOM,IAAI,CAACD,KAAKE,KAAK,CAACZ,UAAU;AAC3D;AAEA,OAAO,SAASa,KAIdC,MAAS,EACTD,IAAO;IAQP,MAAMb,aAAaK,OAAOU,WAAW,CACnCV,OAAOW,OAAO,CAACF,OAAOF,KAAK,CAACZ,UAAU,EAAEiB,MAAM,CAAC,CAAC,CAACd,IAAI,GAAKU,IAAI,CAACV,IAAI;IAErE,OAAOL,WAAWC,OAAO,CAACC;AAC5B;AAEA,OAAO,SAASkB,KAIdJ,MAAS,EACTI,IAAO;IAMP,MAAMlB,aAAaK,OAAOU,WAAW,CACnCV,OAAOW,OAAO,CAACF,OAAOF,KAAK,CAACZ,UAAU,EAAEiB,MAAM,CAAC,CAAC,CAACd,IAAI,GAAK,CAACe,IAAI,CAACf,IAAI;IAEtE,OAAOL,WAAWC,OAAO,CAACC;AAC5B;AAEA,OAAO,SAASmB,OACdC,OAAU,EACVpB,UAAa;IAQb,OAAOF,WAAWC,OAAO,CAAC;QACxB,GAAGqB,QAAQR,KAAK,CAACZ,UAAU;QAC3B,GAAGA,UAAU;IACf;AACF;AAEA,OAAO,SAASqB,MACdD,OAAW,EACXE,OAAW;IAUX,OAAOxB,WAAWC,OAAO,CAAC;QACxB,GAAGqB,QAAQR,KAAK,CAACZ,UAAU;QAC3B,GAAGsB,QAAQV,KAAK,CAACZ,UAAU;IAC7B;AACF;AAEA,OAAO,SAASuB,QAIdC,MAAS;IAMT,MAAMxB,aAAa,CAAC;IAEpB,KAAK,MAAM,CAACG,KAAKsB,MAAM,IAAIpB,OAAOW,OAAO,CAACQ,OAAOZ,KAAK,CAACZ,UAAU,EAAG;QAClEA,UAAU,CAACG,IAAI,GAAGsB,MAAMC,QAAQ;IAClC;IAEA,OAAO5B,WAAWC,OAAO,CAACC,YAAY,CAAC;AACzC"}

package/dist/types/string.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType } from "./base.js";
 export class StringType extends BaseType {
-    _;
     static factory(options = {}) {
         return new StringType(Type.String(options), {
             options

package/dist/types/string.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/string.ts"],"sourcesContent":["import { type StringOptions, type TString, Type } from '@sinclair/typebox'\nimport { BaseType, type ConstantType, type TypeParams } from './base.ts'\n\nexport class StringType extends BaseType<TString, { options: StringOptions }> {\n  _!: ConstantType<TString>\n\n  static factory(options: StringOptions = {}) {\n    return new StringType(Type.String(options), { options })\n  }\n\n  max(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      maxLength: value,\n    })\n  }\n\n  min(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      minLength: value,\n    })\n  }\n\n  format(format: TString['format']) {\n    return StringType.factory({\n      ...this.props.options,\n      pattern: undefined,\n      format,\n    })\n  }\n\n  pattern(pattern: string) {\n    return StringType.factory({\n      ...this.props.options,\n      format: undefined,\n      pattern,\n    })\n  }\n\n  email() {\n    return this.format('email')\n  }\n\n  url() {\n    return this.format('uri')\n  }\n\n  ipv4() {\n    return this.format('ipv4')\n  }\n\n  ipv6() {\n    return this.format('ipv6')\n  }\n\n  uuid() {\n    return this.format('uuid')\n  }\n}\n"],"names":["Type","BaseType","StringType","_","factory","options","String","max","value","props","maxLength","min","minLength","format","pattern","undefined","email","url","ipv4","ipv6","uuid"],"mappings":"AAAA,SAA2CA,IAAI,QAAQ,oBAAmB;AAC1E,SAASC,QAAQ,QAA4C,YAAW;AAExE,OAAO,MAAMC,mBAAmBD;IAC9BE,EAAyB;IAEzB,OAAOC,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIH,WAAWF,KAAKM,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,IAAIC,KAAa,EAAE;QACjB,OAAON,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBK,WAAWF;QACb;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAON,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBO,WAAWJ;QACb;IACF;IAEAK,OAAOA,MAAyB,EAAE;QAChC,OAAOX,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBS,SAASC;YACTF;QACF;IACF;IAEAC,QAAQA,OAAe,EAAE;QACvB,OAAOZ,WAAWE,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBQ,QAAQE;YACRD;QACF;IACF;IAEAE,QAAQ;QACN,OAAO,IAAI,CAACH,MAAM,CAAC;IACrB;IAEAI,MAAM;QACJ,OAAO,IAAI,CAACJ,MAAM,CAAC;IACrB;IAEAK,OAAO;QACL,OAAO,IAAI,CAACL,MAAM,CAAC;IACrB;IAEAM,OAAO;QACL,OAAO,IAAI,CAACN,MAAM,CAAC;IACrB;IAEAO,OAAO;QACL,OAAO,IAAI,CAACP,MAAM,CAAC;IACrB;AACF"}
+{"version":3,"sources":["../../../src/types/string.ts"],"sourcesContent":["import { type StringOptions, type TString, Type } from '@sinclair/typebox'\nimport type { StaticOutputDecode } from '../inference.ts'\nimport { BaseType } from './base.ts'\n\nexport class StringType extends BaseType<\n  TString,\n  { options: StringOptions },\n  string\n> {\n  static factory(options: StringOptions = {}) {\n    return new StringType(Type.String(options), { options })\n  }\n\n  max(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      maxLength: value,\n    })\n  }\n\n  min(value: number) {\n    return StringType.factory({\n      ...this.props.options,\n      minLength: value,\n    })\n  }\n\n  format(format: TString['format']) {\n    return StringType.factory({\n      ...this.props.options,\n      pattern: undefined,\n      format,\n    })\n  }\n\n  pattern(pattern: string) {\n    return StringType.factory({\n      ...this.props.options,\n      format: undefined,\n      pattern,\n    })\n  }\n\n  email() {\n    return this.format('email')\n  }\n\n  url() {\n    return this.format('uri')\n  }\n\n  ipv4() {\n    return this.format('ipv4')\n  }\n\n  ipv6() {\n    return this.format('ipv6')\n  }\n\n  uuid() {\n    return this.format('uuid')\n  }\n}\n"],"names":["Type","BaseType","StringType","factory","options","String","max","value","props","maxLength","min","minLength","format","pattern","undefined","email","url","ipv4","ipv6","uuid"],"mappings":"AAAA,SAA2CA,IAAI,QAAQ,oBAAmB;AAE1E,SAASC,QAAQ,QAAQ,YAAW;AAEpC,OAAO,MAAMC,mBAAmBD;IAK9B,OAAOE,QAAQC,UAAyB,CAAC,CAAC,EAAE;QAC1C,OAAO,IAAIF,WAAWF,KAAKK,MAAM,CAACD,UAAU;YAAEA;QAAQ;IACxD;IAEAE,IAAIC,KAAa,EAAE;QACjB,OAAOL,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBK,WAAWF;QACb;IACF;IAEAG,IAAIH,KAAa,EAAE;QACjB,OAAOL,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBO,WAAWJ;QACb;IACF;IAEAK,OAAOA,MAAyB,EAAE;QAChC,OAAOV,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBS,SAASC;YACTF;QACF;IACF;IAEAC,QAAQA,OAAe,EAAE;QACvB,OAAOX,WAAWC,OAAO,CAAC;YACxB,GAAG,IAAI,CAACK,KAAK,CAACJ,OAAO;YACrBQ,QAAQE;YACRD;QACF;IACF;IAEAE,QAAQ;QACN,OAAO,IAAI,CAACH,MAAM,CAAC;IACrB;IAEAI,MAAM;QACJ,OAAO,IAAI,CAACJ,MAAM,CAAC;IACrB;IAEAK,OAAO;QACL,OAAO,IAAI,CAACL,MAAM,CAAC;IACrB;IAEAM,OAAO;QACL,OAAO,IAAI,CAACN,MAAM,CAAC;IACrB;IAEAO,OAAO;QACL,OAAO,IAAI,CAACP,MAAM,CAAC;IACrB;AACF"}

package/dist/types/union.js

@@ -2,19 +2,20 @@ import { Type } from '@sinclair/typebox';
 import { DiscriminatedUnion } from "../schemas/discriminated-union.js";
 import { BaseType } from "./base.js";
 export class UnionType extends BaseType {
-    _;
-    static factory(...types) {
-        return new UnionType(Type.Union(types.map((t)=>t.schema)));
+    static factory(...options) {
+        return new UnionType(Type.Union(options.map((t)=>t.schema)), {
+            options
+        });
     }
 }
 export class IntersactionType extends BaseType {
-    _;
-    static factory(...types) {
-        return new IntersactionType(Type.Intersect(types.map((t)=>t.schema)));
+    static factory(...options) {
+        return new IntersactionType(Type.Intersect(options.map((t)=>t.schema)), {
+            options
+        });
     }
 }
 export class DiscriminatedUnionType extends BaseType {
-    _;
     static factory(key, ...options) {
         return new DiscriminatedUnionType(DiscriminatedUnion(key, options.map((t)=>t.schema)), {
             key,

package/dist/types/union.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/union.ts"],"sourcesContent":["import {\n  type TIntersect,\n  type TUnion,\n  Type,\n  type UnionToTuple,\n} from '@sinclair/typebox'\nimport {\n  DiscriminatedUnion,\n  type TDiscriminatedUnion,\n} from '../schemas/discriminated-union.ts'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n> extends BaseType<TUnion<UnionToTuple<T[number]['schema']>>> {\n  _!: {\n    encoded: {\n      input: TUnion<UnionToTuple<T[number]['_']['encoded']['input']>>\n      output: TUnion<UnionToTuple<T[number]['_']['encoded']['output']>>\n    }\n    decoded: {\n      input: TUnion<UnionToTuple<T[number]['_']['decoded']['input']>>\n      output: TUnion<UnionToTuple<T[number]['_']['decoded']['output']>>\n    }\n  }\n\n  static factory<T extends readonly BaseType[] = readonly BaseType[]>(\n    ...types: T\n  ) {\n    return new UnionType<T>(Type.Union(types.map((t) => t.schema)) as any)\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n> extends BaseType<TIntersect<UnionToTuple<T[number]['schema']>>> {\n  _!: {\n    encoded: {\n      input: TIntersect<UnionToTuple<T[number]['_']['encoded']['input']>>\n      output: TIntersect<UnionToTuple<T[number]['_']['encoded']['output']>>\n    }\n    decoded: {\n      input: TIntersect<UnionToTuple<T[number]['_']['decoded']['input']>>\n      output: TIntersect<UnionToTuple<T[number]['_']['decoded']['output']>>\n    }\n  }\n\n  static factory<T extends readonly BaseType[] = readonly BaseType[]>(\n    ...types: T\n  ) {\n    return new IntersactionType<T>(\n      Type.Intersect(types.map((t) => t.schema)) as any,\n    )\n  }\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string,\n  T extends readonly [\n    DiscriminatedUnionOptionType<K>,\n    ...DiscriminatedUnionOptionType<K>[],\n  ],\n> extends BaseType<\n  TDiscriminatedUnion<\n    K,\n    //@ts-expect-error\n    UnionToTuple<T[number]['schema']>\n  >,\n  {\n    key: K\n    options: T\n  }\n> {\n  _!: {\n    encoded: {\n      input: TDiscriminatedUnion<\n        K,\n        //@ts-expect-error\n        UnionToTuple<T[number]['_']['encoded']['input']>\n      >\n      output: TDiscriminatedUnion<\n        K,\n        //@ts-expect-error\n        UnionToTuple<T[number]['_']['encoded']['output']>\n      >\n    }\n    decoded: {\n      input: TDiscriminatedUnion<\n        K,\n        //@ts-expect-error\n        UnionToTuple<T[number]['_']['decoded']['input']>\n      >\n      output: TDiscriminatedUnion<\n        K,\n        //@ts-expect-error\n        UnionToTuple<T[number]['_']['decoded']['output']>\n      >\n    }\n  }\n\n  static factory<\n    K extends string,\n    T extends readonly [\n      DiscriminatedUnionOptionType<K>,\n      ...DiscriminatedUnionOptionType<K>[],\n    ],\n  >(key: K, ...options: T) {\n    return new DiscriminatedUnionType<K, T>(\n      DiscriminatedUnion(key, options.map((t) => t.schema) as any),\n      { key, options },\n    )\n  }\n}\n"],"names":["Type","DiscriminatedUnion","BaseType","UnionType","_","factory","types","Union","map","t","schema","IntersactionType","Intersect","DiscriminatedUnionType","key","options"],"mappings":"AAAA,SAGEA,IAAI,QAEC,oBAAmB;AAC1B,SACEC,kBAAkB,QAEb,oCAAmC;AAC1C,SAASC,QAAQ,QAA0B,YAAW;AAItD,OAAO,MAAMC,kBAEHD;IACRE,EASC;IAED,OAAOC,QACL,GAAGC,KAAQ,EACX;QACA,OAAO,IAAIH,UAAaH,KAAKO,KAAK,CAACD,MAAME,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM;IAC9D;AACF;AAEA,OAAO,MAAMC,yBAEHT;IACRE,EASC;IAED,OAAOC,QACL,GAAGC,KAAQ,EACX;QACA,OAAO,IAAIK,iBACTX,KAAKY,SAAS,CAACN,MAAME,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM;IAE5C;AACF;AAMA,OAAO,MAAMG,+BAMHX;IAWRE,EAyBC;IAED,OAAOC,QAMLS,GAAM,EAAE,GAAGC,OAAU,EAAE;QACvB,OAAO,IAAIF,uBACTZ,mBAAmBa,KAAKC,QAAQP,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IACnD;YAAEI;YAAKC;QAAQ;IAEnB;AACF"}
+{"version":3,"sources":["../../../src/types/union.ts"],"sourcesContent":["import {\n  type TIntersect,\n  type TObject,\n  type TSchema,\n  type TUnion,\n  Type,\n  type UnionToTuple,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode } from '../inference.ts'\nimport {\n  DiscriminatedUnion,\n  type DiscriminatedUnionProperties,\n  type TDiscriminatedUnion,\n} from '../schemas/discriminated-union.ts'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n  S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n> extends BaseType<TUnion<S>, { options: T }, StaticInputDecode<TUnion<S>>> {\n  static factory<\n    T extends readonly BaseType[] = readonly BaseType[],\n    S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n  >(...options: T) {\n    return new UnionType<T, S>(\n      Type.Union(options.map((t) => t.schema)) as any,\n      {\n        options,\n      },\n    )\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n  S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n> extends BaseType<\n  TIntersect<S>,\n  { options: T },\n  StaticInputDecode<TIntersect<S>>\n> {\n  static factory<\n    T extends readonly BaseType[] = readonly BaseType[],\n    S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n  >(...options: T) {\n    return new IntersactionType<T, S>(\n      Type.Intersect(options.map((t) => t.schema)) as any,\n      { options },\n    )\n  }\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string = string,\n  T extends\n    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n  S extends TObject<DiscriminatedUnionProperties<K>>[] = [],\n> extends BaseType<\n  TDiscriminatedUnion<K, S>,\n  {\n    key: K\n    options: T\n  },\n  StaticInputDecode<TDiscriminatedUnion<K, S>>\n> {\n  static factory<\n    K extends string,\n    T extends readonly DiscriminatedUnionOptionType<K>[],\n    //@ts-expect-error\n    S extends TObject<DiscriminatedUnionProperties<K>>[] = UnionToTuple<\n      T[number]['schema']\n    >,\n  >(key: K, ...options: T) {\n    return new DiscriminatedUnionType<K, T, S>(\n      DiscriminatedUnion(key, options.map((t) => t.schema) as any),\n      { key, options },\n    )\n  }\n}\n"],"names":["Type","DiscriminatedUnion","BaseType","UnionType","factory","options","Union","map","t","schema","IntersactionType","Intersect","DiscriminatedUnionType","key"],"mappings":"AAAA,SAKEA,IAAI,QAEC,oBAAmB;AAE1B,SACEC,kBAAkB,QAGb,oCAAmC;AAC1C,SAASC,QAAQ,QAA0B,YAAW;AAGtD,OAAO,MAAMC,kBAGHD;IACR,OAAOE,QAGL,GAAGC,OAAU,EAAE;QACf,OAAO,IAAIF,UACTH,KAAKM,KAAK,CAACD,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IACtC;YACEJ;QACF;IAEJ;AACF;AAEA,OAAO,MAAMK,yBAGHR;IAKR,OAAOE,QAGL,GAAGC,OAAU,EAAE;QACf,OAAO,IAAIK,iBACTV,KAAKW,SAAS,CAACN,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IAC1C;YAAEJ;QAAQ;IAEd;AACF;AAMA,OAAO,MAAMO,+BAKHV;IAQR,OAAOE,QAOLS,GAAM,EAAE,GAAGR,OAAU,EAAE;QACvB,OAAO,IAAIO,uBACTX,mBAAmBY,KAAKR,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IACnD;YAAEI;YAAKR;QAAQ;IAEnB;AACF"}

package/package.json

@@ -12,21 +12,21 @@
       "default": "./dist/compiler.js",
       "types": "./src/compiler.ts"
     },
+    "./runtime": {
+      "bun": "./src/runtime.ts",
+      "default": "./dist/runtime.js",
+      "types": "./src/runtime.ts"
+    },
     "./temporal": {
       "bun": "./src/temporal.ts",
       "default": "./dist/temporal.js",
       "types": "./src/temporal.ts"
     }
   },
-  "peerDependencies": {
-    "@sinclair/typebox": "^0.34.13",
-    "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.5.2"
-  },
-  "devDependencies": {
+  "dependencies": {
     "@sinclair/typebox": "^0.34.13",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.5.2"
+    "@nmtjs/common": "0.6.0"
   },
   "files": [
     "src",
@@ -35,7 +35,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.5.2",
+  "version": "0.6.0",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"