functional-models 2.0.14 → 2.1.1

package/README.md

@@ -21,6 +21,7 @@ Functional Models was born out of the enjoyment and power of working with Django
 - Many common properties out of the box.
 - Supports foreign keys, 1 to 1 as well as 1 to many (via an Array).
 - Supports custom primary key name. (id is used by default)
+- Supports different model namings, (plural, singular, display), and the ability to customize them.
 
 ## Simple JavaScript Example Usage
 
@@ -263,15 +264,60 @@ validation requirements, etc.
 
 ### List of Properties Out-Of-The-Box
 
-- UniqueId // A UUID property
-- DateProperty // A property for dates. Includes the ability to "autoNow".
-- ArrayProperty // An array property which can be used to limit types within it.
-- ModelReferenceProperty // A property that references another property. (Think Foreign Key)
-- AdvancedModelReferenceProperty // A more fuller/advanced property for referencing other properties.
-- IntegerProperty // A property for integers.
-- TextProperty // A text or string property.
-- ConstantValueProperty // A property that contains a single, unchanging, static value.
-- NumberProperty // A property for float/number types.
-- ObjectProperty // A property that has a JavaScript object. (Not a foreign key references)
-- EmailProperty // An email property.
-- BooleanProperty // A true or false value property.
+#### UniqueId
+
+A UUID Property.
+
+#### NaturalIdProperty
+
+An id that is composed of other properties on an object. It is "natural" in the sense that it is
+not an arbitrary id, but rather a mixture of properties that make up a unique instance. This is often
+useful for when creating a "key" property.
+
+NOTE: This property is never automatically updated if the properties changed. It is recommended that
+any model that has a NaturalIdProperty should be deleted and then re-created rather than "updated" if
+any property changes that make up the key composition.
+
+#### DateProperty
+
+A property for dates. Includes the ability to "autoNow".
+
+#### ArrayProperty
+
+An array property which can be used to limit types within it.
+
+#### IntegerProperty
+
+A property for integers.
+
+#### TextProperty
+
+A text or string property.
+
+#### ConstantValueProperty
+
+A property that contains a single, unchanging, static value.
+
+#### NumberProperty
+
+A property for float/number types.
+
+#### ObjectProperty
+
+A property that has a JavaScript object. (Not a foreign key references)
+
+#### EmailProperty
+
+An email property.
+
+#### BooleanProperty
+
+A true or false value property.
+
+#### ModelReferenceProperty
+
+A property that references another property. (Think Foreign Key)
+
+#### AdvancedModelReferenceProperty
+
+A more fuller/advanced property for referencing other properties. Useful for typescripting.

package/errors.d.ts

@@ -1,9 +1,9 @@
-declare type KeysToErrors = {
-    readonly [s: string]: readonly string[];
-};
+declare type KeysToErrors = Readonly<{
+    [s: string]: readonly string[];
+}>;
 declare class ValidationError extends Error {
-    modelName: String;
+    modelName: string;
     keysToErrors: KeysToErrors;
-    constructor(modelName: String, keysToErrors: KeysToErrors);
+    constructor(modelName: string, keysToErrors: KeysToErrors);
 }
 export { ValidationError };

package/errors.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationError = void 0;
-/* eslint-disable functional/no-this-expression */
-/* eslint-disable functional/no-class */
+/* eslint-disable functional/no-this-expressions */
+/* eslint-disable functional/no-classes */
 class ValidationError extends Error {
     constructor(modelName, keysToErrors) {
         super(`${modelName} did not pass validation`);

package/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEA,kDAAkD;AAClD,wCAAwC;AACxC,MAAM,eAAgB,SAAQ,KAAK;IAGjC,YAAY,SAAiB,EAAE,YAA0B;QACvD,KAAK,CAAC,GAAG,SAAS,0BAA0B,CAAC,CAAA;QAC7C,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;CACF;AAIQ,0CAAe"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEA,mDAAmD;AACnD,0CAA0C;AAC1C,MAAM,eAAgB,SAAQ,KAAK;IAGjC,YAAY,SAAiB,EAAE,YAA0B;QACvD,KAAK,CAAC,GAAG,SAAS,0BAA0B,CAAC,CAAA;QAC7C,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;CACF;AAIQ,0CAAe"}

package/index.d.ts

@@ -6,5 +6,4 @@ import * as utils from './utils';
 import * as interfaces from './interfaces';
 export * from './models';
 export * from './properties';
-export * from './methods';
 export { constants, errors, validation, serialization, utils, interfaces };

package/index.js

@@ -37,5 +37,4 @@ const interfaces = __importStar(require("./interfaces"));
 exports.interfaces = interfaces;
 __exportStar(require("./models"), exports);
 __exportStar(require("./properties"), exports);
-__exportStar(require("./methods"), exports);
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uDAAwC;AAW/B,8BAAS;AAVlB,iDAAkC;AAUd,wBAAM;AAT1B,yDAA0C;AASd,gCAAU;AARtC,+DAAgD;AAQR,sCAAa;AAPrD,+CAAgC;AAOuB,sBAAK;AAN5D,yDAA0C;AAMoB,gCAAU;AAJxE,2CAAwB;AACxB,+CAA4B;AAC5B,4CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uDAAwC;AAU/B,8BAAS;AATlB,iDAAkC;AASd,wBAAM;AAR1B,yDAA0C;AAQd,gCAAU;AAPtC,+DAAgD;AAOR,sCAAa;AANrD,+CAAgC;AAMuB,sBAAK;AAL5D,yDAA0C;AAKoB,gCAAU;AAHxE,2CAAwB;AACxB,+CAA4B"}

package/interfaces.d.ts

@@ -4,62 +4,35 @@ declare type Nullable<T> = T | null;
 declare type Maybe<T> = T | undefined | null;
 declare type Arrayable<T> = T | readonly T[];
 declare type MaybeLazy<T> = Maybe<Promise<T>>;
-declare type UnWrapPromises<T> = {
-    readonly [P in keyof T]: Awaited<T[P]>;
-};
-declare type JsonObj = {
-    readonly [s: string]: JsonAble | null;
-};
-declare type NoFunctions<T> = RemoveType<T, (...args: readonly any[]) => any>;
+declare type JsonObj = Readonly<{
+    [s: string]: JsonAble | null;
+}>;
 declare type TypedJsonObj<T extends FunctionalModel> = {
-    readonly [P in keyof NoFunctions<UnWrapPromises<T>>]: JsonAble;
+    readonly [P in keyof T]: JsonAble;
 };
 declare type JsonAble = Arrayable<JsonObj> | readonly (number | string | boolean)[] | number | string | boolean | null;
 declare type VeryPrimitivesTypes = null | string | number | boolean;
 declare type toObj<T extends FunctionalModel> = () => Promise<TypedJsonObj<T>>;
-declare type ValueIsOfType<T, V> = {
-    readonly [P in keyof T as T[P] extends V ? P : never]: T[P];
-};
-declare type ModelMethod<T extends FunctionalModel = FunctionalModel, TModel extends Model<T> = Model<T>> = (model: TModel, ...args: readonly any[]) => any;
-declare type ModelMethodClient = (...args: readonly any[]) => any;
-declare type ModelMethods<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = ValueIsOfType<T, ModelMethod | ModelMethod<T> | ModelMethod<T, TModel>>;
-declare type ModelMethodGetters<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = {
-    readonly [P in keyof T as T[P] extends ModelMethod<T, TModel> | ModelMethod<T> | ModelMethod ? P : never]: ModelMethodClient;
-};
-declare type ModelInstanceMethod<T extends FunctionalModel = FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = (instance: TModelInstance, model: TModel, ...args: readonly any[]) => any;
-declare type ModelInstanceMethodClient = (...args: readonly any[]) => any;
-declare type RemoveType<T, TRemove> = {
-    readonly [P in keyof T as T[P] extends TRemove ? never : P]: T[P];
-};
-declare type NotModelMethods<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = RemoveType<T, ModelMethod | ModelMethod<T> | ModelMethod<T, TModel>>;
-declare type InstanceMethodGetters<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = {
-    readonly [P in keyof NotModelMethods<T, TModel> as NotModelMethods<T, TModel>[P] extends ModelInstanceMethod | ModelInstanceMethod<T, TModel> | ModelInstanceMethod<T, TModel, TModelInstance> | ModelInstanceMethod<T, TModel, any> ? P : never]: ModelInstanceMethodClient;
-};
-declare type ModelMethodTypes<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = ModelMethod | ModelMethod<T> | ModelMethod<T, TModel> | ModelInstanceMethod | ModelInstanceMethod<T> | ModelInstanceMethod<T, TModel> | ModelInstanceMethod<T, TModel, any>;
-declare type InstanceMethods<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = ValueIsOfType<T, ModelInstanceMethod | ModelInstanceMethod<T> | ModelInstanceMethod<T, TModel> | ModelInstanceMethod<T, TModel, TModelInstance>>;
-declare type PropertyGetters<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = {
-    readonly [Property in keyof T as T[Property] extends ModelMethodTypes<T, TModel> ? never : Property]: () => T[Property];
-};
-declare type FunctionalModel = ({
-    readonly [s: string]: Arrayable<number> | Promise<number> | Arrayable<string> | Arrayable<boolean> | Arrayable<null> | Arrayable<FunctionalModel> | Arrayable<Date> | Arrayable<undefined> | ModelReference<any> | ModelInstanceMethod | ModelMethod;
-} & {
-    readonly id?: PrimaryKeyType;
-});
-declare type FunctionalValue = MaybePromise<JsonAble | (() => FunctionalValue) | Arrayable<null> | Arrayable<undefined> | Arrayable<Date> | Arrayable<FunctionalModel> | Arrayable<{
-    readonly [s: string]: JsonAble;
-}>>;
-declare type ModelInstanceInputData<T extends FunctionalModel> = RemoveType<T, (...args: readonly any[]) => any> | UnWrapPromises<T> | TypedJsonObj<T>;
-declare type ValidatorConfiguration = {
-    readonly [s: string]: any;
-};
+declare type PropertyGetters<T extends FunctionalModel> = {
+    readonly [Property in keyof T]: () => T[Property];
+};
+declare type FunctionalModel = Readonly<{
+    [s: string]: Arrayable<number> | Promise<number> | Arrayable<string> | Arrayable<boolean> | Arrayable<null> | Arrayable<FunctionalModel> | Arrayable<Date> | Arrayable<undefined> | ModelReference<any> | Arrayable<JsonAble>;
+}> & Readonly<{
+    id?: PrimaryKeyType;
+}>;
+declare type FunctionalValue = MaybePromise<Arrayable<JsonAble> | (() => FunctionalValue) | Arrayable<null> | Arrayable<undefined> | Arrayable<Date> | Arrayable<FunctionalModel>>;
+declare type ValidatorConfiguration = Readonly<{
+    [s: string]: any;
+}>;
 declare type ValidationErrorResponse = string | undefined;
 declare type ValidationErrors = readonly string[];
 declare type ModelError = string | undefined;
-declare type ModelErrors<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = {
-    readonly [Property in keyof T as T[Property] extends ModelMethodTypes<T, TModel> ? never : Property]: readonly string[] | undefined;
-} & {
-    readonly overall?: readonly string[] | undefined;
-};
+declare type ModelErrors<T extends FunctionalModel> = {
+    readonly [Property in keyof T]: readonly string[] | undefined;
+} & Readonly<{
+    overall?: readonly string[] | undefined;
+}>;
 declare type PropertyValidatorComponentTypeAdvanced<TValue, T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = (value: TValue, instance: TModelInstance, instanceData: T | JsonAble, configurations: ValidatorConfiguration) => ValidationErrorResponse;
 declare type PropertyValidatorComponentSync<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = PropertyValidatorComponentTypeAdvanced<any, T, TModel, TModelInstance>;
 declare type ValuePropertyValidatorComponent<T extends Arrayable<FunctionalValue>> = (value: T) => ValidationErrorResponse;
@@ -68,103 +41,105 @@ declare type PropertyValidatorComponent<T extends FunctionalModel, TModel extend
 declare type PropertyValidator<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = (instance: TModelInstance, instanceData: T | JsonAble, configurations: ValidatorConfiguration) => Promise<ValidationErrors>;
 declare type ModelValidatorComponent<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = (instance: TModelInstance, instanceData: T | JsonAble, configurations: ValidatorConfiguration) => Promise<ModelError>;
 declare type ValueGetter<TValue extends Arrayable<FunctionalValue>, T extends FunctionalModel = FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = () => MaybePromise<TValue | TModelInstance>;
-declare type PropertyInstance<TValue extends Arrayable<FunctionalValue>, T extends FunctionalModel = FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = {
-    readonly getConfig: () => object;
-    readonly getChoices: () => readonly VeryPrimitivesTypes[];
-    readonly getDefaultValue: () => TValue;
-    readonly getConstantValue: () => TValue;
-    readonly getPropertyType: () => string;
-    readonly createGetter: (value: TValue) => ValueGetter<TValue, T, TModel, TModelInstance>;
-    readonly getValidator: (valueGetter: ValueGetter<TValue, T, TModel, TModelInstance>) => PropertyValidator<TModel>;
-};
+declare type PropertyInstance<TValue extends Arrayable<FunctionalValue>, T extends FunctionalModel = FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = Readonly<{
+    getConfig: () => object;
+    getChoices: () => readonly VeryPrimitivesTypes[];
+    getDefaultValue: () => TValue;
+    getConstantValue: () => TValue;
+    getPropertyType: () => string;
+    createGetter: (value: TValue, modelData: T, modelInstance: TModelInstance) => ValueGetter<TValue, T, TModel, TModelInstance>;
+    getValidator: (valueGetter: ValueGetter<TValue, T, TModel, TModelInstance>) => PropertyValidator<T, TModel, TModelInstance>;
+}>;
 declare type PropertiesList<T extends FunctionalModel> = {
     readonly [P in keyof T as T[P] extends Arrayable<FunctionalValue> ? P : never]: PropertyInstance<any>;
 };
-interface ModelReferencePropertyInstance<T extends FunctionalModel, TProperty extends Arrayable<FunctionalValue>, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> extends PropertyInstance<TProperty> {
-    readonly getReferencedId: (instanceValues: ModelReference<T, TModel, TModelInstance>) => Maybe<PrimaryKeyType>;
+interface ModelReferencePropertyInstance<T extends FunctionalModel, TProperty extends Arrayable<FunctionalValue>, TModel extends Model<T> = Model<T>> extends PropertyInstance<TProperty> {
+    readonly getReferencedId: (instanceValues: ModelReference<T>) => Maybe<PrimaryKeyType>;
     readonly getReferencedModel: () => TModel;
 }
-declare type ModelReference<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = TModelInstance | ModelInstanceInputData<T> | PrimaryKeyType;
-declare type DefaultPropertyValidators = {
-    readonly required?: boolean;
-    readonly isInteger?: boolean;
-    readonly isNumber?: boolean;
-    readonly isString?: boolean;
-    readonly isArray?: boolean;
-    readonly isBoolean?: boolean;
-};
-declare type PropertyConfigContents<T extends Arrayable<FunctionalValue>> = {
-    readonly type?: string;
-    readonly defaultValue?: T;
-    readonly value?: T;
-    readonly choices?: readonly VeryPrimitivesTypes[];
-    readonly lazyLoadMethod?: (value: T) => MaybeLazy<T>;
-    readonly valueSelector?: (instanceValue: MaybePromise<T>) => T;
-    readonly validators?: readonly PropertyValidatorComponent<any>[];
-    readonly maxLength?: number;
-    readonly minLength?: number;
-    readonly maxValue?: number;
-    readonly minValue?: number;
-    readonly autoNow?: boolean;
-    readonly fetcher?: ModelFetcher;
-};
-declare type ModelFetcher = <T extends FunctionalModel, TModel extends Model<T> = Model<T>>(model: TModel, primaryKey: PrimaryKeyType) => Promise<ModelInstance<T, TModel>> | Promise<ModelInstanceInputData<T>> | Promise<null> | Promise<undefined>;
+declare type ModelReference<T extends FunctionalModel> = T | TypedJsonObj<T> | PrimaryKeyType;
+declare type DefaultPropertyValidators = Readonly<{
+    required?: boolean;
+    isInteger?: boolean;
+    isNumber?: boolean;
+    isString?: boolean;
+    isArray?: boolean;
+    isBoolean?: boolean;
+}>;
+declare type PropertyConfigContents<T extends Arrayable<FunctionalValue>> = Readonly<{
+    type?: string;
+    defaultValue?: T;
+    value?: T;
+    choices?: readonly VeryPrimitivesTypes[];
+    lazyLoadMethod?: <TData extends FunctionalModel>(value: T, modelData: TData) => MaybeLazy<T>;
+    valueSelector?: (instanceValue: MaybePromise<T>) => T;
+    validators?: readonly PropertyValidatorComponent<any>[];
+    maxLength?: number;
+    minLength?: number;
+    maxValue?: number;
+    minValue?: number;
+    autoNow?: boolean;
+    fetcher?: ModelFetcher;
+}>;
+declare type ModelFetcher = <T extends FunctionalModel, TModel extends Model<T> = Model<T>>(model: TModel, primaryKey: PrimaryKeyType) => Promise<T | TypedJsonObj<T>> | Promise<null> | Promise<undefined>;
 declare type PropertyConfig<T extends Arrayable<FunctionalValue>> = (PropertyConfigContents<T> & DefaultPropertyValidators) | undefined;
 declare type PrimaryKeyPropertyInstanceType = PropertyInstance<string> | PropertyInstance<number>;
 declare type PrimaryKeyType = string | number;
-declare type ModelDefinition<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = {
-    readonly getPrimaryKeyName?: () => string;
-    readonly properties: PropertiesList<T> & {
-        readonly id?: PrimaryKeyPropertyInstanceType;
-    };
-    readonly modelMethods?: ModelMethods<T, TModel>;
-    readonly instanceMethods?: InstanceMethods<T, TModel, TModelInstance>;
-    readonly modelValidators?: readonly ModelValidatorComponent<T, TModel>[];
-};
-declare type ModelFactory = <T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>>(modelName: string, modelDefinition: ModelDefinition<T, TModel, TModelInstance>, options?: OptionalModelOptions<T, TModel, TModelInstance>) => TModel;
-declare type CreateParams<T extends FunctionalModel> = ModelInstanceInputData<T> | (ModelInstanceInputData<T> & {
-    readonly id?: PrimaryKeyType;
-});
-declare type Model<T extends FunctionalModel> = {
-    readonly getName: () => string;
-    readonly getPrimaryKeyName: () => string;
-    readonly getModelDefinition: () => ModelDefinition<T>;
-    readonly getPrimaryKey: (t: ModelInstanceInputData<T>) => PrimaryKeyType;
-    readonly getOptions: () => object & ModelOptions<T>;
-    readonly create: (data: CreateParams<T>) => ModelInstance<T>;
-    readonly methods: ModelMethodGetters<T>;
-};
-declare type ModelReferenceFunctions = {
-    readonly [s: string]: () => ModelReference<any>;
-};
-declare type PropertyValidators<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = {
-    readonly [s: string]: PropertyValidator<T, TModel>;
-};
-declare type ModelInstance<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = {
-    readonly get: PropertyGetters<T, TModel> & {
-        readonly id: () => MaybePromise<PrimaryKeyType>;
+declare type ModelDefinition<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = Readonly<{
+    getPrimaryKeyName?: () => string;
+    properties: {
+        id?: PrimaryKeyPropertyInstanceType;
+    } & PropertiesList<T>;
+    modelValidators?: readonly ModelValidatorComponent<T, TModel>[];
+    singularName?: string;
+    displayName?: string;
+}>;
+declare type ModelFactory = <T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>>(pluralName: string, modelDefinition: ModelDefinition<T, TModel>, options?: OptionalModelOptions<T, TModel, TModelInstance>) => TModel;
+declare type CreateParams<T extends FunctionalModel> = T | TypedJsonObj<T> | (TypedJsonObj<T> & Readonly<{
+    id?: PrimaryKeyType;
+}>);
+declare type Model<T extends FunctionalModel> = Readonly<{
+    getName: () => string;
+    getSingularName: () => string;
+    getDisplayName: () => string;
+    getPrimaryKeyName: () => string;
+    getModelDefinition: () => ModelDefinition<T>;
+    getPrimaryKey: (t: T | TypedJsonObj<T>) => PrimaryKeyType;
+    getOptions: () => object & ModelOptions<T>;
+    create: (data: CreateParams<T>) => ModelInstance<T>;
+}>;
+declare type ModelReferenceFunctions = Readonly<{
+    [s: string]: () => Maybe<PrimaryKeyType>;
+}>;
+declare type PropertyValidators<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = Readonly<{
+    id?: PropertyValidator<T, TModel>;
+}> & Readonly<{
+    [s: string]: PropertyValidator<T, TModel>;
+}>;
+declare type ModelInstance<T extends FunctionalModel, TModel extends Model<T> = Model<T>> = Readonly<{
+    get: PropertyGetters<T> & {
+        id?: () => MaybePromise<PrimaryKeyType>;
     };
-    readonly methods: InstanceMethodGetters<T, TModel>;
-    readonly references: ModelReferenceFunctions;
-    readonly toObj: toObj<T>;
-    readonly getPrimaryKeyName: () => string;
-    readonly getPrimaryKey: () => PrimaryKeyType;
-    readonly validators: PropertyValidators<T, TModel>;
-    readonly validate: (options?: {}) => Promise<ModelErrors<T, TModel>>;
-    readonly getModel: () => TModel;
-};
+    references: ModelReferenceFunctions;
+    toObj: toObj<T>;
+    getPrimaryKeyName: () => string;
+    getPrimaryKey: () => PrimaryKeyType;
+    validators: PropertyValidators<T, TModel>;
+    validate: (options?: object) => Promise<ModelErrors<T>>;
+    getModel: () => TModel;
+}>;
 declare type ValueRequired<T extends Arrayable<FunctionalValue>> = NonNullable<T>;
 declare type ValueOptional<T extends Arrayable<FunctionalValue>> = Maybe<T>;
-declare type ValueOptionalR<T extends FunctionalModel> = ValueOptional<ModelReference<T>>;
 declare type ValueRequiredR<T extends FunctionalModel> = ValueRequired<ModelReference<T>>;
+declare type ValueOptionalR<T extends FunctionalModel> = ValueOptional<ModelReference<T>>;
 declare type IsAsync<T extends Arrayable<FunctionalValue>> = Promise<T>;
 declare type PropertyModifier<T extends Arrayable<FunctionalValue>> = ValueRequired<T> | ValueOptional<T> | T;
-declare type ModelOptions<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = {
-    readonly instanceCreatedCallback: Nullable<Arrayable<(instance: TModelInstance) => void>>;
-    readonly [s: string]: any;
-};
-declare type OptionalModelOptions<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = {
-    readonly instanceCreatedCallback?: Nullable<Arrayable<(instance: TModelInstance) => void>>;
-    readonly [s: string]: any;
-} | undefined;
-export { MaybeFunction, Maybe, MaybePromise, Nullable, Arrayable, MaybeLazy, JsonAble, toObj, ModelInstance, Model, PropertyValidatorComponent, PropertyValidatorComponentSync, PropertyValidatorComponentAsync, PropertyValidator, ModelValidatorComponent, PropertyInstance, PropertyConfig, FunctionalValue, ValueGetter, ModelReference, ModelDefinition, ModelOptions, ModelMethod, OptionalModelOptions, ModelReferencePropertyInstance, PropertyGetters, PropertyValidators, PropertyValidatorComponentTypeAdvanced, ModelInstanceMethod, FunctionalModel, ModelInstanceInputData, ModelMethodGetters, InstanceMethodGetters, ModelReferenceFunctions, ModelErrors, PrimaryKeyType, ModelFactory, ModelFetcher, CreateParams, ValidatorConfiguration, ValuePropertyValidatorComponent, ValueRequired, ValueOptional, ValueOptionalR, ValueRequiredR, PropertyModifier, ValidationErrors, ModelError, IsAsync, ModelInstanceMethodClient, ModelMethodClient, TypedJsonObj, JsonObj, };
+declare type ModelOptions<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = Readonly<{
+    instanceCreatedCallback: Nullable<Arrayable<(instance: TModelInstance) => void>>;
+    [s: string]: any;
+}>;
+declare type OptionalModelOptions<T extends FunctionalModel, TModel extends Model<T> = Model<T>, TModelInstance extends ModelInstance<T, TModel> = ModelInstance<T, TModel>> = Readonly<{
+    instanceCreatedCallback?: Nullable<Arrayable<(instance: TModelInstance) => void>>;
+    [s: string]: any;
+}> | undefined;
+export { MaybeFunction, Maybe, MaybePromise, Nullable, Arrayable, MaybeLazy, JsonAble, toObj, ModelInstance, Model, PropertyValidatorComponent, PropertyValidatorComponentSync, PropertyValidatorComponentAsync, PropertyValidator, ModelValidatorComponent, PropertyInstance, PropertyConfig, FunctionalValue, ValueGetter, ModelReference, ModelDefinition, ModelOptions, OptionalModelOptions, ModelReferencePropertyInstance, PropertyGetters, PropertyValidators, PropertyValidatorComponentTypeAdvanced, FunctionalModel, ModelReferenceFunctions, ModelErrors, PrimaryKeyType, ModelFactory, ModelFetcher, CreateParams, ValidatorConfiguration, ValuePropertyValidatorComponent, ValueRequired, ValueOptional, PropertyModifier, ValidationErrors, ModelError, IsAsync, TypedJsonObj, JsonObj, ValueRequiredR, ValueOptionalR, };

package/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;AAyeA,kCAAkC"}
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;AA0XA,kCAAkC"}

package/lazy.d.ts

@@ -1,2 +1,2 @@
-declare const lazyValue: (method: Function) => (...args: readonly any[]) => Promise<any>;
+declare const lazyValue: (method: (...args: any[]) => any) => (...args: readonly any[]) => Promise<any>;
 export { lazyValue };

package/lazy.js.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../src/lazy.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,4DAAkC;AAClC,mCAAoC;AAEpC,MAAM,SAAS,GAAG,CAAC,MAAgB,EAAE,EAAE;IACrC,MAAM,GAAG,GAAG,IAAA,kBAAU,GAAE,CAAA;IACxB,MAAM,IAAI,GAAG,IAAI,oBAAS,EAAE,CAAA;IAC5B,sCAAsC;IACtC,IAAI,KAAK,GAAQ,SAAS,CAAA;IAC1B,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,OAAO,CAAO,GAAG,IAAoB,EAAE,EAAE;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAS,EAAE;YAClC,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,GAAG,IAAI,CAAA;gBACb,KAAK,GAAG,MAAM,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;gBAC7B,kDAAkD;aACnD;YAED,OAAO,KAAK,CAAA;QACd,CAAC,CAAA,CAAC,CAAA;IACJ,CAAC,CAAA,CAAA;IACD,qCAAqC;AACvC,CAAC,CAAA;AAEQ,8BAAS"}
+{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../src/lazy.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,4DAAkC;AAClC,mCAAoC;AAEpC,MAAM,SAAS,GAAG,CAAC,MAA+B,EAAE,EAAE;IACpD,MAAM,GAAG,GAAG,IAAA,kBAAU,GAAE,CAAA;IACxB,MAAM,IAAI,GAAG,IAAI,oBAAS,EAAE,CAAA;IAC5B,sCAAsC;IACtC,IAAI,KAAK,GAAQ,SAAS,CAAA;IAC1B,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,OAAO,CAAO,GAAG,IAAoB,EAAE,EAAE;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAS,EAAE;YAClC,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,GAAG,IAAI,CAAA;gBACb,KAAK,GAAG,MAAM,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;gBAC7B,kDAAkD;aACnD;YAED,OAAO,KAAK,CAAA;QACd,CAAC,CAAA,CAAC,CAAA;IACJ,CAAC,CAAA,CAAA;IACD,qCAAqC;AACvC,CAAC,CAAA;AAEQ,8BAAS"}