@routier/core 0.0.1-alpha.1

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

@@ -0,0 +1,49 @@
+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

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

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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,14 @@
+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/modifiers/index.ts

@@ -0,0 +1,12 @@
+export * from './SchemaDefault';
+export * from './SchemaDeserialize';
+export * from './SchemaDistinct';
+export * from './SchemaIdentity';
+export * from './SchemaIndex';
+export * from './SchemaKey';
+export * from './SchemaNullable';
+export * from './SchemaOptional';
+export * from './SchemaReadonly';
+export * from './SchemaSerialize';
+export * from './SchemaTracked';
+export * from './SchemaFrom';

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,69 @@
+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);
+    }
+}