@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/schema/property/base/SchemaBase.ts

@@ -1,49 +0,0 @@
-import { DefaultValue, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-
-export abstract class SchemaBase<T extends any, TModifiers extends SchemaModifiers> {
-
-    abstract instance: T;
-    modifiers: TModifiers;
-
-    isNullable: boolean = false;
-    isUnmapped: boolean = false;
-    isOptional: boolean = false;
-    isKey: boolean = false;
-    isIdentity: boolean = false;
-    isReadonly: boolean = false;
-    isDistict: boolean = false;
-    indexes: string[] = [];
-    fromPropertyName: string | null = null;
-
-    injected: any = null;
-    defaultValue: DefaultValue<T> | null = null;
-    valueSerializer: PropertySerializer<T> | null = null;
-    valueDeserializer: PropertyDeserializer<T> | null = null;
-    type: SchemaTypes;
-    functionBody: FunctionBody<any, T> | null;
-    private _schemaBase = true;
-    readonly literals: T[] = [];
-
-    constructor(entity?: SchemaBase<T, TModifiers>, literals?: T[]) {
-
-        if (entity != null) {
-            this.valueSerializer = entity.valueSerializer;
-            this.valueDeserializer = entity.valueDeserializer;
-            this.functionBody = entity.functionBody;
-            this.isNullable = entity.isNullable;
-            this.isOptional = entity.isOptional;
-            this.isKey = entity.isKey;
-            this.isIdentity = entity.isIdentity;
-            this.isReadonly = entity.isReadonly;
-            this.defaultValue = entity.defaultValue;
-            this.type = entity.type;
-            this.injected = entity.injected;
-            this.indexes = entity.indexes;
-            this.fromPropertyName = entity.fromPropertyName;
-        }
-
-        if (literals) {
-            this.literals = literals;
-        }
-    }
-}

package/src/schema/property/base/index.ts

@@ -1 +0,0 @@
-export * from './SchemaBase';

package/src/schema/property/modifiers/SchemaDefault.ts

@@ -1,29 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDeserialize } from "./SchemaDeserialize";
-import { SchemaFrom } from "./SchemaFrom";
-import { SchemaSerialize } from "./SchemaSerialize";
-
-export class SchemaDefault<T extends any, I, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaDefault = true;
-
-    constructor(defaultValue: DefaultValue<T, I>, injected: I, current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.injected = injected;
-        this.defaultValue = defaultValue;
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-}

package/src/schema/property/modifiers/SchemaDeserialize.ts

@@ -1,23 +0,0 @@
-import { PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaFrom } from "./SchemaFrom";
-import { SchemaSerialize } from "./SchemaSerialize";
-
-export class SchemaDeserialize<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaDeserialize = true;
-
-    constructor(deserializer: PropertyDeserializer<T>, current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.valueDeserializer = deserializer;
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-}

package/src/schema/property/modifiers/SchemaDistinct.ts

@@ -1,14 +0,0 @@
-import { SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-
-export class SchemaDistinct<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    private _schemaDistinct = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isDistict = true;
-    }
-}

package/src/schema/property/modifiers/SchemaFrom.ts

@@ -1,54 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "./SchemaDefault";
-import { SchemaDeserialize } from "./SchemaDeserialize";
-import { SchemaDistinct } from "./SchemaDistinct";
-import { SchemaIdentity } from "./SchemaIdentity";
-import { SchemaKey } from "./SchemaKey";
-import { SchemaNullable } from "./SchemaNullable";
-import { SchemaOptional } from "./SchemaOptional";
-import { SchemaReadonly } from "./SchemaReadonly";
-import { SchemaSerialize } from "./SchemaSerialize";
-
-export class SchemaFrom<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaFrom = true;
-
-    constructor(propertyName: string, current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.fromPropertyName = propertyName;
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-
-    identity() {
-        return new SchemaIdentity<T, TModifiers | "identity" | "readonly">(this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-}

package/src/schema/property/modifiers/SchemaIdentity.ts

@@ -1,13 +0,0 @@
-import { SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-
-export class SchemaIdentity<T, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaIdentity = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isIdentity = true;
-    }
-}

package/src/schema/property/modifiers/SchemaIndex.ts

@@ -1,60 +0,0 @@
-import { uuidv4 } from "../../../utilities";
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "./SchemaDefault";
-import { SchemaDeserialize } from "./SchemaDeserialize";
-import { SchemaDistinct } from "./SchemaDistinct";
-import { SchemaFrom } from "./SchemaFrom";
-import { SchemaNullable } from "./SchemaNullable";
-import { SchemaOptional } from "./SchemaOptional";
-import { SchemaReadonly } from "./SchemaReadonly";
-import { SchemaSerialize } from "./SchemaSerialize";
-
-export class SchemaIndex<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    private _schemaIndex = true;
-
-    constructor(current: SchemaBase<T, TModifiers>, ...indexes: string[]) {
-        super(current);
-        this.instance = current.instance;
-
-        if (indexes.length === 0) {
-            indexes.push(uuidv4()); // Create our own unique index identifier
-        }
-
-        this.indexes = indexes;
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-}

package/src/schema/property/modifiers/SchemaKey.ts

@@ -1,28 +0,0 @@
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaIdentity } from "./SchemaIdentity";
-import { SchemaDefault } from "./SchemaDefault";
-import { DefaultValue, IdType, SchemaModifiers } from "../../types";
-import { SchemaFrom } from "./SchemaFrom";
-
-export class SchemaKey<T extends IdType, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaKey = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isKey = true;
-    }
-
-    identity() {
-        return new SchemaIdentity<T, TModifiers | "identity">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-}

package/src/schema/property/modifiers/SchemaNullable.ts

@@ -1,18 +0,0 @@
-import { SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaOptional } from "./SchemaOptional";
-
-export class SchemaNullable<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaNullable = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isNullable = true;
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-}

package/src/schema/property/modifiers/SchemaOptional.ts

@@ -1,19 +0,0 @@
-import { SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaNullable } from "./SchemaNullable";
-
-export class SchemaOptional<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    private _schemaOptional = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isOptional = true;
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-}

package/src/schema/property/modifiers/SchemaReadonly.ts

@@ -1,34 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "./SchemaDefault";
-import { SchemaDeserialize } from "./SchemaDeserialize";
-import { SchemaFrom } from "./SchemaFrom";
-import { SchemaSerialize } from "./SchemaSerialize";
-
-export class SchemaReadonly<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    private _schemaReadonly = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isReadonly = true;
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    deserializer(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serializer(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "deserialize">(serializer, this);
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-}

package/src/schema/property/modifiers/SchemaSerialize.ts

@@ -1,18 +0,0 @@
-import { PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDeserialize } from "./SchemaDeserialize";
-
-export class SchemaSerialize<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    private _schemaSerialize = true;
-
-    constructor(serializer: PropertySerializer<T>, current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.valueSerializer = serializer;
-    }
-
-    deserializer(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-}

package/src/schema/property/modifiers/SchemaTracked.ts

@@ -1,14 +0,0 @@
-import { SchemaModifiers } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-
-export class SchemaTracked<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    private _schemaTracked = true;
-
-    constructor(current: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.instance = current.instance;
-        this.isUnmapped = false;
-    }
-}

package/src/schema/property/types/SchemaArray.ts

@@ -1,50 +0,0 @@
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaDeserialize } from '../modifiers/SchemaDeserialize';
-import { SchemaSerialize } from '../modifiers/SchemaSerialize';
-import { SchemaIndex } from "../modifiers/SchemaIndex";
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-
-export class SchemaArray<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T[], TModifiers> {
-
-    instance: T[];
-    type = SchemaTypes.Array;
-    private _schemaArray = true;
-    readonly innerSchema?: SchemaBase<any, any>; // we need to know the type of the array, that is what this is for
-
-    constructor(entity?: SchemaBase<T[], TModifiers>, literals?: T[][]) {
-        super(entity, literals);
-        this.innerSchema = entity;
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T[], TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T[], TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T[], TModifiers | "nullable">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T[], I>, injected?: I) {
-        return new SchemaDefault<T[], I, TModifiers | "default">(value, injected, this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T[]>) {
-        return new SchemaDeserialize<T[], TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T[]>) {
-        return new SchemaSerialize<T[], TModifiers | "serialize">(serializer, this);
-    }
-
-    index(...indexes: string[]) {
-        return new SchemaIndex<T[], TModifiers>(this as any, ...indexes);
-    }
-}

package/src/schema/property/types/SchemaBoolean.ts

@@ -1,59 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
-import { SchemaDistinct } from "../modifiers/SchemaDistinct";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-import { SchemaIndex } from "../modifiers/SchemaIndex";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaReadonly } from "../modifiers/SchemaReadonly";
-import { SchemaSerialize } from "../modifiers/SchemaSerialize";
-import { SchemaArray } from "./SchemaArray";
-
-export class SchemaBoolean<T extends boolean, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    type = SchemaTypes.Boolean;
-    private _schemaBoolean = true;
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    array() {
-        return new SchemaArray<typeof this, TModifiers>(this as any);
-    }
-
-    index(...indexes: string[]) {
-        return new SchemaIndex<T, TModifiers>(this as any, ...indexes);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-}

package/src/schema/property/types/SchemaDate.ts

@@ -1,58 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
-import { SchemaDistinct } from "../modifiers/SchemaDistinct";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-import { SchemaIndex } from "../modifiers/SchemaIndex";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaReadonly } from "../modifiers/SchemaReadonly";
-import { SchemaSerialize } from "../modifiers/SchemaSerialize";
-import { SchemaArray } from "./SchemaArray";
-
-export class SchemaDate<T extends Date, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    type = SchemaTypes.Date;
-    private _schemaDate = true;
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    array() {
-        return new SchemaArray<typeof this, TModifiers>(this as any);
-    }
-
-    index(...indexes: string[]) {
-        return new SchemaIndex<T, TModifiers>(this as any, ...indexes);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-}

package/src/schema/property/types/SchemaNumber.ts

@@ -1,69 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
-import { SchemaDistinct } from "../modifiers/SchemaDistinct";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-import { SchemaIdentity } from "../modifiers/SchemaIdentity";
-import { SchemaIndex } from "../modifiers/SchemaIndex";
-import { SchemaKey } from "../modifiers/SchemaKey";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaReadonly } from "../modifiers/SchemaReadonly";
-import { SchemaSerialize } from "../modifiers/SchemaSerialize";
-import { SchemaArray } from "./SchemaArray";
-
-export class SchemaNumber<T extends number, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    type = SchemaTypes.Number;
-    private _schemaNumber = true;
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    key() {
-        return new SchemaKey<T, TModifiers | "key">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    identity() {
-        return new SchemaIdentity<T, TModifiers | "identity" | "readonly">(this);
-    }
-
-    array() {
-        return new SchemaArray<typeof this, TModifiers>(this as any);
-    }
-
-    index(...indexes: string[]) {
-        return new SchemaIndex<T, TModifiers>(this as any, ...indexes);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-}