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

package/dist/schema/property/base/SchemaBase.d.ts

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

package/dist/schema/property/base/index.d.ts

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

package/dist/schema/property/modifiers/SchemaDefault.d.ts

@@ -0,0 +1,13 @@
+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 declare class SchemaDefault<T extends any, I, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaDefault;
+    constructor(defaultValue: DefaultValue<T, I>, injected: I, current: SchemaBase<T, TModifiers>);
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaDeserialize.d.ts

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

package/dist/schema/property/modifiers/SchemaDistinct.d.ts

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

package/dist/schema/property/modifiers/SchemaFrom.d.ts

@@ -0,0 +1,23 @@
+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 { SchemaNullable } from "./SchemaNullable";
+import { SchemaOptional } from "./SchemaOptional";
+import { SchemaReadonly } from "./SchemaReadonly";
+import { SchemaSerialize } from "./SchemaSerialize";
+export declare class SchemaFrom<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaFrom;
+    constructor(propertyName: string, current: SchemaBase<T, TModifiers>);
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaIdentity.d.ts

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

package/dist/schema/property/modifiers/SchemaIndex.d.ts

@@ -0,0 +1,23 @@
+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 declare class SchemaIndex<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaIndex;
+    constructor(current: SchemaBase<T, TModifiers>, ...indexes: string[]);
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaKey.d.ts

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

package/dist/schema/property/modifiers/SchemaNullable.d.ts

@@ -0,0 +1,9 @@
+import { SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaOptional } from "./SchemaOptional";
+export declare class SchemaNullable<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaNullable;
+    constructor(current: SchemaBase<T, TModifiers>);
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaOptional.d.ts

@@ -0,0 +1,9 @@
+import { SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaNullable } from "./SchemaNullable";
+export declare class SchemaOptional<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaOptional;
+    constructor(current: SchemaBase<T, TModifiers>);
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaReadonly.d.ts

@@ -0,0 +1,15 @@
+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 declare class SchemaReadonly<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaReadonly;
+    constructor(current: SchemaBase<T, TModifiers>);
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    deserializer(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serializer(serializer: PropertySerializer<T>): SchemaSerialize<T, "deserialize" | TModifiers>;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaSerialize.d.ts

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

package/dist/schema/property/modifiers/SchemaTracked.d.ts

@@ -0,0 +1,7 @@
+import { SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+export declare class SchemaTracked<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaTracked;
+    constructor(current: SchemaBase<T, TModifiers>);
+}

package/{src/schema/property/modifiers/index.ts → dist/schema/property/modifiers/index.d.ts}

@@ -9,4 +9,4 @@ export * from './SchemaOptional';
 export * from './SchemaReadonly';
 export * from './SchemaSerialize';
 export * from './SchemaTracked';
-export * from './SchemaFrom';
+export * from './SchemaFrom';

package/dist/schema/property/types/SchemaArray.d.ts

@@ -0,0 +1,23 @@
+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 declare class SchemaArray<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T[], TModifiers> {
+    instance: T[];
+    type: SchemaTypes;
+    private _schemaArray;
+    readonly innerSchema?: SchemaBase<any, any>;
+    constructor(entity?: SchemaBase<T[], TModifiers>, literals?: T[][]);
+    from(propertyName: string): SchemaFrom<T[], TModifiers>;
+    optional(): SchemaOptional<T[], "optional" | TModifiers>;
+    nullable(): SchemaNullable<T[], "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T[], I>, injected?: I): SchemaDefault<T[], I, "default" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T[]>): SchemaDeserialize<T[], "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T[]>): SchemaSerialize<T[], "serialize" | TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T[], TModifiers>;
+}

package/dist/schema/property/types/SchemaBoolean.d.ts

@@ -0,0 +1,27 @@
+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 declare class SchemaBoolean<T extends boolean, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaBoolean;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/dist/schema/property/types/SchemaDate.d.ts

@@ -0,0 +1,27 @@
+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 declare class SchemaDate<T extends Date, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaDate;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/dist/schema/property/types/SchemaNumber.d.ts

@@ -0,0 +1,31 @@
+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 declare class SchemaNumber<T extends number, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaNumber;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    key(): SchemaKey<T, "key" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/dist/schema/property/types/SchemaObject.d.ts

@@ -0,0 +1,20 @@
+import { DefaultValue, SchemaModifiers, SchemaTypes } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "../modifiers/SchemaDefault";
+import { SchemaFrom } from "../modifiers/SchemaFrom";
+import { SchemaIdentity } from "../modifiers/SchemaIdentity";
+import { SchemaNullable } from "../modifiers/SchemaNullable";
+import { SchemaOptional } from "../modifiers/SchemaOptional";
+import { SchemaArray } from "./SchemaArray";
+export declare class SchemaObject<T extends {}, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaObject;
+    constructor(schema: T);
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+}

package/dist/schema/property/types/SchemaString.d.ts

@@ -0,0 +1,31 @@
+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 declare class SchemaString<T extends string, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaString;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    key(): SchemaKey<T, "key" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/{src/schema/property/types/index.ts → dist/schema/property/types/index.d.ts}

@@ -3,4 +3,4 @@ export * from './SchemaBoolean';
 export * from './SchemaDate';
 export * from './SchemaNumber';
 export * from './SchemaObject';
-export * from './SchemaString';
+export * from './SchemaString';

package/dist/schema/table/SchemaComputed.d.ts

@@ -0,0 +1,10 @@
+import { SchemaBase } from "../property/base/SchemaBase";
+import { SchemaTracked } from '../property/modifiers/SchemaTracked';
+import { SchemaModifiers, SchemaTypes } from "../types";
+export declare class SchemaComputed<T extends any, I, TModifiers extends SchemaModifiers = "computed"> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    type: SchemaTypes;
+    private _schemaComputed;
+    constructor(fn: T, injected: I, current?: SchemaBase<T, TModifiers>);
+    tracked(): SchemaTracked<T, TModifiers>;
+}

package/dist/schema/table/SchemaFunction.d.ts

@@ -0,0 +1,8 @@
+import { SchemaBase } from "../property/base/SchemaBase";
+import { SchemaModifiers, SchemaTypes } from "../types";
+export declare class SchemaFunction<T extends any, I, TModifiers extends SchemaModifiers = "unmapped"> extends SchemaBase<() => T, TModifiers> {
+    instance: () => T;
+    type: SchemaTypes;
+    private _schemaFunction;
+    constructor(fn: (injected: I) => T, injected: I, current?: SchemaBase<() => T, TModifiers>);
+}

package/{src/schema/table/index.ts → dist/schema/table/index.d.ts}

@@ -1,2 +1,2 @@
 export * from './SchemaComputed';
-export * from './SchemaFunction';
+export * from './SchemaFunction';