From 3718dbe64f446f074a03ff63536efb99bf84d90c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Zab=C5=82ocki?= <tomasz.zablocki@gmail.com>
Date: Mon, 29 Jul 2019 23:05:26 +0200
Subject: [PATCH] overhaul typings based on Model declaration merging

---
 types/redux-orm/Model.d.ts         | 607 ++++++++++++-----------------
 types/redux-orm/ORM.d.ts           |  68 ++--
 types/redux-orm/QuerySet.d.ts      | 133 +++----
 types/redux-orm/Session.d.ts       |  24 +-
 types/redux-orm/constants.d.ts     |  25 +-
 types/redux-orm/db/Database.d.ts   |  96 ++---
 types/redux-orm/db/Table.d.ts      |  91 ++---
 types/redux-orm/db/index.d.ts      |   4 +-
 types/redux-orm/fields.d.ts        |  36 +-
 types/redux-orm/helpers.d.ts       |  17 +-
 types/redux-orm/index.d.ts         |  64 +--
 types/redux-orm/redux-orm-tests.ts |  62 ++-
 types/redux-orm/redux.d.ts         |  78 ++--
 13 files changed, 510 insertions(+), 795 deletions(-)

diff --git a/types/redux-orm/Model.d.ts b/types/redux-orm/Model.d.ts
index 7ce2794..bfe11ee 100644
--- a/types/redux-orm/Model.d.ts
+++ b/types/redux-orm/Model.d.ts
@@ -1,49 +1,8 @@
-import { Attribute, AttributeWithDefault, FieldSpecMap, ForeignKey, OneToOne } from './fields';
-import { KnownKeys, OptionalKeys, PickByValue } from './helpers';
+import { Attribute, AttributeWithDefault, ForeignKey, ManyToMany, OneToOne } from './fields';
+import { OptionalKeys, PickByValue, Serializable } from './helpers';
 import QuerySet, { MutableQuerySet } from './QuerySet';
-import { OrmSession } from './Session';
 import { Table } from './db';
-
-/**
- * A primitive value
- */
-export type Primitive = number | string | boolean;
-
-/**
- * Serializable value: a primitive, undefined, a serializable object or an array of those
- */
-export type Serializable =
-    | Primitive
-    | Primitive[]
-    | undefined
-    | {
-          [K: string]: Serializable | Serializable[];
-      };
-
-/**
- * A union of supported model field types
- *
- * Specify foreign key and one-to-one association properties as Model typed properties.
- *
- * Specify many-to-many and reverse-fk associations as related Model's specification of:
- * - {@link MutableQuerySet} - for many-to-many relations
- * - {@link QuerySet} - for reverse side of foreign keys
- */
-export type ModelField = QuerySet | SessionBoundModel | Serializable;
-
-/**
- * Map of fields restriction to supported field types.
- */
-export interface ModelFieldMap {
-    [K: string]: ModelField;
-}
-
-/**
- * A Model-derived mapped type for supplying relations and alike.
- *
- * Either a primitive type matching Model's identifier type or an object implementing a `{ getId(): IdType<M> }` interface
- */
-export type IdOrModelLike<M extends Model> = IdType<M> | { getId(): IdType<M> };
+import { OrmSession } from './Session';
 
 /**
  * The heart of an ORM, the data model.
@@ -62,12 +21,15 @@ export type IdOrModelLike<M extends Model> = IdType<M> | { getId(): IdType<M> };
  * To create data models in your schema, subclass {@link Model}. To define
  * information about the data model, override static class methods. Define instance
  * logic by defining prototype methods (without `static` keyword).
- * @borrows {@link QuerySet.filter} as Model#filter
+ *
+ * Specify foreign key and one-to-one association properties as Model typed properties.
+ *
+ * Specify many-to-many and reverse-fk associations as related Model's specification of:
+ * - {@link MutableQuerySet} - for many-to-many relations
+ * - {@link QuerySet} - for reverse side of foreign keys
  */
-export class Model<MClass extends typeof AnyModel = typeof AnyModel, Fields extends ModelFieldMap = any> {
-    /**
-     * A string constant identifying specific Model, necessary to retain the shape of state and relations through transpilation steps
-     */
+export class Model<MClass extends Model.Class = any> {
+    /** A string constant identifying specific Model. **Setting {@link Model#modelName} is mandatory.** */
     static modelName: string;
 
     /**
@@ -77,7 +39,7 @@ export class Model<MClass extends typeof AnyModel = typeof AnyModel, Fields exte
      * @see {@link ForeignKey}
      * @see {@link ManyToMany}
      */
-    static fields: FieldSpecMap;
+    static fields: Record<string, Attribute | ForeignKey | ManyToMany | OneToOne>;
 
     /**
      * Returns the options object passed to the database for the table that represents
@@ -91,12 +53,8 @@ export class Model<MClass extends typeof AnyModel = typeof AnyModel, Fields exte
      * @return the options object passed to the database for the table
      *                  representing this Model class.
      */
-    static options: (() => Table.TableOpts) | Table.TableOpts;
+    static options: { (): Model.ModelOpts } | Model.ModelOpts;
 
-    /**
-     * The key of Model's identifier property
-     */
-    static readonly idAttribute: string;
     /**
      * {@link QuerySet} class associated with this Model class.
      *
@@ -104,105 +62,42 @@ export class Model<MClass extends typeof AnyModel = typeof AnyModel, Fields exte
      */
     static querySetClass: typeof QuerySet;
 
-    /**
-     * @see {@link Model.getQuerySet}
-     */
-    static query: QuerySet;
-    /**
-     * Returns a reference to the plain JS object in the store.
-     * Make sure to not mutate this.
-     *
-     * @return a reference to the plain JS object in the store
-     */
-    readonly ref: Ref<this>;
-    __fields: Fields;
-    __descriptors: MClass['fields'];
-    __class: MClass;
+    /** The key of Model's identifier property. */
+    static readonly idAttribute: string;
 
-    /**
-     * Creates a Model instance from it's properties.
-     * Don't use this to create a new record; Use the static method {@link Model#create}.
-     * @param props - the properties to instantiate with
-     */
-    constructor(props: Fields);
+    /** @see {@link Model.getQuerySet} */
+    static readonly query: QuerySet;
 
     /**
-     * Gets the {@link Model} class or subclass constructor (the class that
-     * instantiated this instance).
+     * Returns an instance of the model's {@link Model#querySetClass} field.
+     * By default, this will be an empty {@link QuerySet}.
      *
-     * @return The {@link Model} class or subclass constructor used to instantiate
-     *                 this instance.
-     */
-    getClass(): MClass;
-
-    /**
-     * Gets the id value of the current instance by looking up the id attribute.
-     * @return The id value of the current instance.
-     */
-    getId<Id extends Fields[Table.IdAttribute<MClass>] = Fields[Table.IdAttribute<MClass>]>(): Id extends undefined ? number : Id;
-
-    /**
-     * @return A string representation of this {@link Model} instance.
+     * @return An instance of the model's {@link Model#querySetClass}.
      */
-    toString(): string;
+    static getQuerySet<M extends Model>(this: Model.Class<M>): QuerySet<M>;
 
     /**
-     * Returns a boolean indicating if `otherModel` equals this {@link Model} instance.
-     * Equality is determined by shallow comparing their attributes.
+     * Returns a {@link Model} instance for the object with id `id`.
+     * Returns `null` if the model has no instance with id `id`.
      *
-     * This equality is used when you call {@link Model#update}.
-     * You can prevent model updates by returning `true` here.
-     * However, a model will always be updated if its relationships are changed.
+     * You can use {@link Model#idExists} to check for existence instead.
      *
-     * @param  otherModel - a {@link Model} instance to compare
-     * @return a boolean indicating if the {@link Model} instance's are equal.
+     * @param  id - the `id` of the object to get
+     * @return a {@link Model} instance with id `id`
      */
-    equals(otherModel: Model | SessionBoundModel): boolean;
+    static withId<M extends Model>(this: Model.Class<M>, id: Model.IdType<M>): M | null;
 
     /**
-     * Updates a property name to given value for this {@link Model} instance.
-     * The values are immediately committed to the database.
+     * Returns a boolean indicating if an entity
+     * with the id `id` exists in the state.
      *
-     * @param  propertyName - name of the property to set
-     * @param value - value assigned to the property
-     */
-    set<K extends string>(propertyName: K, value: RefPropOrSimple<this, K>): void;
-
-    /**
-     * Assigns multiple fields and corresponding values to this {@link Model} instance.
-     * The updates are immediately committed to the database.
+     * @param   id - a value corresponding to the id attribute of the {@link Model} class.
+     * @return a boolean indicating if entity with `id` exists in the state
      *
-     * @param userMergeObj - an object that will be merged with this instance.
-     */
-    update(userMergeObj: UpdateProps<InstanceType<MClass>>): void;
-
-    /**
-     * Updates {@link Model} instance attributes to reflect the
-     * database state in the current session.
-     */
-    refreshFromState(): void;
-
-    /**
-     * Deletes the record for this {@link Model} instance.
-     * Fields and values on the instance are still accessible after the call.
-     */
-    delete(): void;
-
-    /**
-     * @see {@link QuerySet.delete}
+     * @since 0.11.0
      */
-    static delete(): void;
-}
-
-export namespace Model {
-    type MCtor<M extends Model> = new (...args: any[]) => M;
+    static idExists<M extends Model>(this: Model.Class<M>, id: Model.IdType<M>): boolean;
 
-    function reducer<M extends AnyModel>(
-        this: MCtor<M>,
-        action: any,
-        model: M extends infer R ? (R extends Model ? ReturnType<R['getClass']> : never) : never,
-        session: OrmSession<any>
-    ): void;
     /**
      * Creates a new record in the database, instantiates a {@link Model} and returns it.
      *
@@ -210,12 +105,12 @@ export namespace Model {
      * model as well.
      *
      * @param  props - the new {@link Model}'s properties.
-     * @return a new {@link SessionBoundModel} instance.
+     * @return a new {@link Model} instance.
      */
-    function create<M extends AnyModel, TProps extends CreateProps<M>>(
-        this: MCtor<M>,
+    static create<M extends Model, TProps extends Model.CreateProps<M>>(
+        this: Model.Class<M>,
         props: TProps
-    ): SessionBoundModel<M, CustomInstanceProps<M, TProps>>;
+    ): M & Model.CustomProps<M, TProps>;
 
     /**
      * Creates a new or update existing record in the database, instantiates a {@link Model} and returns it.
@@ -224,50 +119,66 @@ export namespace Model {
      * model as well.
      *
      * @param  props - the upserted {@link Model}'s properties.
-     * @return a {@link SessionBoundModel} instance.
+     * @return a {@link Model} instance.
      */
-    function upsert<M extends AnyModel, TProps extends UpsertProps<M>>(
-        this: MCtor<M>,
+    static upsert<M extends Model, TProps extends Model.UpsertProps<M>>(
+        this: Model.Class<M>,
         props: TProps
-    ): SessionBoundModel<M, CustomInstanceProps<M, TProps>>;
+    ): M & Model.CustomProps<M, TProps>;
 
-    /**
-     * Gets the {@link Model} instance that matches properties in `lookupObj`.
-     * Throws an error if {@link Model} if multiple records match
-     * the properties.
-     *
-     * @param  lookupSpec - the properties used to match a single entity.
-     * @throws {Error} If more than one entity matches the properties in `lookupObj`.
-     * @return a {@link SessionBoundModel} instance that matches the properties in `lookupObj`.
-     */
-    function get<M extends AnyModel>(this: MCtor<M>, lookupSpec: QuerySet.LookupSpec<M>): SessionBoundModel<M> | null;
+    /** @see {@link QuerySet.QueryBuilder.delete} */
+    static delete(): void;
 
-    /**
-     * Returns a {@link Model} instance for the object with id `id`.
-     * Returns `null` if the model has no instance with id `id`.
-     *
-     * You can use {@link Model#idExists} to check for existence instead.
-     *
-     * @param  id - the `id` of the object to get
-     * @return a {@link SessionBoundModel} instance with id `id`
-     */
-    function withId<M extends AnyModel>(this: MCtor<M>, id: IdType<M>): SessionBoundModel<M> | null;
+    /** @see {@link QuerySet.QueryBuilder.all} */
+    static all<M extends Model>(this: Model.Class<M>): QuerySet<M>;
+
+    /** @see {@link QuerySet.QueryBuilder.at} */
+    static at<M extends Model>(this: Model.Class<M>, index: number): M | undefined;
+
+    /** @see {@link QuerySet.QueryBuilder.first} */
+    static first<M extends Model>(this: Model.Class<M>): M | undefined;
+
+    /** @see {@link QuerySet.QueryBuilder.last} */
+    static last<M extends Model>(this: Model.Class<M>): M | undefined;
+
+    /** @see {@link QuerySet.QueryBuilder.update} */
+    static update<M extends Model>(this: Model.Class<M>, props: Model.UpdateProps<M>): void;
+
+    /** @see {@link QuerySet.QueryBuilder.filter} */
+    static filter<M extends Model>(this: Model.Class<M>, props: QuerySet.LookupSpec<M>): QuerySet<M>;
+
+    /** @see {@link QuerySet.QueryBuilder.exclude} */
+    static exclude<M extends Model>(this: Model.Class<M>, props: QuerySet.LookupSpec<M>): QuerySet<M>;
+
+    /** @see {@link QuerySet.QueryBuilder.orderBy} */
+    static orderBy<M extends Model>(
+        this: Model.Class<M>,
+        iteratees: ReadonlyArray<QuerySet.SortIteratee<M>>,
+        orders?: ReadonlyArray<QuerySet.SortOrder>
+    ): QuerySet<M>;
+
+    /** @see {@link QuerySet.QueryBuilder.count} */
+    static count(): number;
 
     /**
      * Returns a boolean indicating if an entity
-     * with the id `id` exists in the state.
-     *
-     * @param   id - a value corresponding to the id attribute of the {@link Model} class.
-     * @return a boolean indicating if entity with `id` exists in the state
+     * with the given props exists in the state.
      *
-     * @since 0.11.0
+     * @param  props - a key-value that {@link Model} instances should have to be considered as existing.
+     * @return a boolean indicating if entity with `props` exists in the state
      */
-    function idExists<M extends AnyModel>(this: MCtor<M>, id: IdType<M>): boolean;
+    static exists<M extends Model>(this: Model.Class<M>, props: QuerySet.LookupProps<M>): boolean;
 
     /**
-     * @return A string representation of this {@link Model} class.
+     * Gets the {@link Model} instance that matches properties in `lookupObj`.
+     * Throws an error if {@link Model} if multiple records match
+     * the properties.
+     *
+     * @param  lookupSpec - the properties used to match a single entity.
+     * @throws {Error} If more than one entity matches the properties in `lookupObj`.
+     * @return a {@link Model} instance that matches the properties in `lookupObj`.
      */
-    function toString(): string;
+    static get<M extends Model>(this: Model.Class<M>, lookupSpec: QuerySet.LookupSpec<M>): M | null;
 
     /**
      * Manually mark individual instances as accessed.
@@ -275,241 +186,203 @@ export namespace Model {
      *
      * @param ids - Array of primary key values
      */
-    function markAccessed(ids: Array<string | number>): void;
+    static markAccessed<M extends Model>(this: Model.Class<M>, ids: Array<Model.IdType<M>>): void;
 
     /**
      * Manually mark this model's table as scanned.
      * This allows invalidating selector memoization within mutable sessions.
-     *
      */
-    function markFullTableScanned(): void;
+    static markFullTableScanned(): void;
 
-    /**
-     * Returns an instance of the model's `querySetClass` field.
-     * By default, this will be an empty {@link QuerySet}.
-     *
-     * @return An instance of the model's `querySetClass`.
-     */
-    function getQuerySet<M extends AnyModel>(this: MCtor<M>): QuerySet<M>;
+    static reducer<M extends Model>(
+        this: Model.Class<M>,
+        action: any,
+        model: M extends infer R ? (R extends Model ? Model.ExtractClass<R> : never) : never,
+        session: OrmSession<any>
+    ): void;
 
     /**
-     * @see {@link QuerySet.all}
+     * Returns a reference to the plain JS object in the store.
+     * Make sure to not mutate this.
+     *
+     * @return a reference to the plain JS object in the store
      */
-    function all<M extends AnyModel>(this: MCtor<M>): QuerySet<M>;
+    readonly ref: Model.Ref<InstanceType<MClass>>;
 
     /**
-     * @see {@link QuerySet.at}
+     * Creates a Model instance from it's properties.
+     * Don't use this to create a new record; Use the static method {@link Model#create}.
+     * @param props - the properties to instantiate with.
      */
-    function at<M extends AnyModel>(this: MCtor<M>, index: number): SessionBoundModel<M> | undefined;
+    constructor(props: object);
 
     /**
-     * @see {@link QuerySet.first}
+     * Gets the {@link Model} class or subclass constructor (the class that
+     * instantiated this instance).
+     *
+     * @return The {@link Model} class or subclass constructor used to instantiate
+     *                 this instance.
      */
-    function first<M extends AnyModel>(this: MCtor<M>): SessionBoundModel<M> | undefined;
+    getClass(): MClass;
 
     /**
-     * @see {@link QuerySet.last}
+     * Gets the id value of the current instance by looking up the id attribute.
+     * @return The id value of the current instance.
      */
-    function last<M extends AnyModel>(this: MCtor<M>): SessionBoundModel<M> | undefined;
+    getId(): Model.IdType<InstanceType<MClass>>;
 
     /**
-     * @see {@link QuerySet.update}
+     * Returns a boolean indicating if `otherModel` equals this {@link Model} instance.
+     * Equality is determined by shallow comparing their attributes.
+     *
+     * This equality is used when you call {@link Model#update}.
+     * You can prevent model updates by returning `true` here.
+     * However, a model will always be updated if its relationships are changed.
+     *
+     * @param  otherModel - a {@link Model} instance to compare
+     * @return a boolean indicating if the {@link Model} instance's are equal.
      */
-    function update<M extends AnyModel>(this: MCtor<M>, props: UpdateProps<M>): void;
+    equals(otherModel: Model): boolean;
 
     /**
-     * @see {@link QuerySet.filter}
+     * Updates a property name to given value for this {@link Model} instance.
+     * The values are immediately committed to the database.
+     *
+     * @param  propertyName - name of the property to set
+     * @param value - value assigned to the property
      */
-    function filter<M extends AnyModel>(this: MCtor<M>, props: QuerySet.LookupSpec<M>): QuerySet<M>;
+    set<K extends string>(propertyName: K, value: K extends keyof this['ref'] ? this['ref'][K] : Serializable): void;
 
     /**
-     * @see {@link QuerySet.exclude}
+     * Assigns multiple fields and corresponding values to this {@link Model} instance.
+     * The updates are immediately committed to the database.
+     *
+     * @param userMergeObj - an object that will be merged with this instance.
      */
-    function exclude<M extends AnyModel>(this: MCtor<M>, props: QuerySet.LookupSpec<M>): QuerySet<M>;
+    update(userMergeObj: Model.UpdateProps<InstanceType<MClass>>): void;
 
     /**
-     * @see {@link QuerySet.orderBy}
+     * Updates {@link Model} instance attributes to reflect the
+     * database state in the current session.
      */
-    function orderBy<M extends AnyModel>(
-        this: MCtor<M>,
-        iteratees: ReadonlyArray<QuerySet.SortIteratee<M>>,
-        orders?: ReadonlyArray<QuerySet.SortOrder>
-    ): QuerySet<M>;
+    refreshFromState(): void;
 
     /**
-     * @see {@link QuerySet.count}
+     * Deletes the record for this {@link Model} instance.
+     * Fields and values on the instance are still accessible after the call.
      */
-    function count(): number;
+    delete(): void;
+}
 
+export namespace Model {
     /**
-     * Returns a boolean indicating if an entity
-     * with the given props exists in the state.
-     *
-     * @param  props - a key-value that {@link Model} instances should have to be considered as existing.
-     * @return a boolean indicating if entity with `props` exists in the state
+     * Shape of {@link Model} constructor function, with Model configuration properties
      */
-    function exists<M extends AnyModel>(this: MCtor<M>, props: QuerySet.LookupProps<M>): boolean;
-}
+    interface Class<M extends Model = any> {
+        new (...args: any[]): M;
+        modelName: string;
+        fields: Record<string, Attribute | ForeignKey | ManyToMany | OneToOne>;
+        options?: { (): ModelOpts } | ModelOpts;
+    }
 
-/**
- * Model wildcard type.
- */
-export class AnyModel extends Model {}
-
-/**
- * {@link Model#update} argument type
- *
- * All properties are optional.
- * Supplied properties are type-checked against the type of related Model's fields.
- * Relations can be provided in a flexible manner for both many-to-many and foreign key associations
- * @see {@link IdOrModelLike}
- */
-
-/**
- * @internal
- */
-export type CustomInstanceProps<M extends AnyModel, Props extends object> = Omit<
-    Props,
-    Extract<keyof Props, KnownKeys<ModelBlueprint<M>>>
->;
-
-/**
- * Model id property key extraction helper.
- *
- * Falls back to `'id'` if not specified explicitly via {@link Model.options}.
- */
-export type IdKey<M extends AnyModel> = Table.IdAttribute<M['__class']> extends infer R
-    ? R extends keyof ModelFields<M>
-        ? R
-        : never
-    : never;
-
-/**
- * Model id property type extraction helper.
- *
- * Falls back to `number` if not specified explicitly via {@link Model.options}.
- */
-export type IdType<M extends Model> = FieldAt<M, IdKey<M>> extends string ? string : number;
-
-/**
- * A mapped type restricting allowed types of second {@link Model.set} argument.
- * Depending on the first argument `propertyName` argument, value type can be restricted to:
- * - declared Model field type - if propertyName belongs to declared Model fields
- * - any serializable value - if propertyName is not among declared Model fields
- */
-export type RefPropOrSimple<M extends AnyModel, K extends string> = K extends keyof M['ref']
-    ? M['ref'][K]
-    : Serializable;
-
-/**
- * A Model-derived mapped type, representing model instance bound to a session.
- *
- * SessionBoundModels relation properties for convenient association traversal.
- * Custom type-checked properties are available on `SessionBoundModel` instances created using
- * @link Model#create} or {@link Model#upsert} calls.
- */
-export type SessionBoundModel<M extends Model = any, InstanceProps extends object = {}> = M &
-    { [K in keyof ModelFields<M>]: FieldAt<M, K> extends AnyModel ? SessionBoundModel<FieldAt<M, K>> : FieldAt<M, K> } &
-    InstanceProps;
-
-/**
- * @internal
- */
-export type ModelClass<M extends AnyModel> = ReturnType<M['getClass']>;
-
-/**
- * @internal
- */
-export type ModelFields<M extends AnyModel> = M['__fields'];
-
-export type FieldAt<M extends Model, K extends keyof ModelFields<M>> = ModelFields<M>[K];
+    /** Model id property key extraction helper. */
+    type IdKey<M extends Model> = Table.IdAttribute<ExtractClass<M>> extends infer Id
+        ? Id extends keyof M
+            ? Id
+            : never
+        : never;
 
-/**
- * @internal
- */
-export type FieldSpecKeys<M extends AnyModel, TField> = Extract<
-    keyof ModelFields<M>,
-    keyof PickByValue<M['__descriptors'], TField>
->;
+    /** Model id property type extraction helper. */
+    type IdType<M extends Model> = M[IdKey<M>];
 
-/**
- * Type of {@link Model.ref} / database entry for a particular Model type
- */
-// export type Ref<M extends AnyModel> = {
-//     [K in FieldSpecKeys<M, Attribute | ForeignKey | OneToOne>]: FieldAt<M, K> extends AnyModel
-//         ? IdType<FieldAt<M, K>>
-//         : FieldAt<M, K>;
-// };
-export type Ref<M extends AnyModel> = {
-    [K in keyof PickByValue<M['__descriptors'], Attribute | ForeignKey | OneToOne>]: K extends keyof M['__fields']
-        ? M['__fields'][K] extends AnyModel
-            ? IdType<M['__fields'][K]>
-            : M['__fields'][K]
-        : never;
-};
-
-export type ModelBlueprint<M extends AnyModel, Fields extends ModelFields<M> = ModelFields<M>> = {
-    [K in keyof Fields]: Fields[K] extends AnyModel
-        ? IdOrModelLike<Fields[K]>
-        : Fields[K] extends MutableQuerySet<infer RM>
-        ? ReadonlyArray<IdOrModelLike<RM>>
-        : Fields[K];
-};
-
-export type NonBlueprintKeys<M extends AnyModel> = Exclude<
-    keyof PickByValue<Required<ModelFields<M>>, AnyModel | QuerySet>,
-    FieldSpecKeys<M, OneToOne | ForeignKey> | keyof PickByValue<Required<ModelFields<M>>, MutableQuerySet>
->;
-
-export type BlueprintProps<M extends ModelBlueprint<Model>, ReqKeys extends keyof any, OptKeys extends keyof any> = {
-    [K in ReqKeys]-?: M[K];
-} &
-    {
-        [K in OptKeys]+?: M[K];
+    /** Type of {@link Model.ref} / database entry for a particular Model type */
+    type Ref<M extends Model> = {
+        [K in FieldDescriptorKeys<M, Attribute | ForeignKey | OneToOne>]: M[K] extends Model ? IdType<M[K]> : M[K];
     };
 
-export type IdKeyOpt<M extends AnyModel> = IdType<M> extends number ? IdKey<M> : never;
-
-/**
- * {@link Model#create} argument type
- *
- * Relations can be provided in a flexible manner for both many-to-many and foreign key associations
- * @see {@link IdOrModelLike}
- */
-export type CreateProps<
-    M extends AnyModel,
-    Fields extends Omit<ModelFields<M>, NonBlueprintKeys<M>> = Omit<ModelFields<M>, NonBlueprintKeys<M>>,
-    MQsKeys extends keyof PickByValue<Fields, MutableQuerySet> = keyof PickByValue<Fields, MutableQuerySet>,
-    OptAttrKeys extends keyof any = FieldSpecKeys<M, AttributeWithDefault> | IdKeyOpt<M>,
-    OptKeys extends keyof any = MQsKeys | OptionalKeys<Fields> | OptAttrKeys
-> = BlueprintProps<ModelBlueprint<M>, Exclude<keyof Fields, OptKeys>, OptKeys>;
+    /** @internal */
+    type ExtractClass<M extends Model> = M extends { getClass(): infer R } ? R : never;
+
+    /** @internal */
+    type FieldDescriptorKeys<M extends Model, TField> = keyof PickByValue<
+        ExtractClass<M>['fields'],
+        TField
+    > extends infer R
+        ? R extends keyof M
+            ? R
+            : never
+        : never;
 
-/**
- * {@link Model#upsert} argument type
- *
- * All properties aside from identifier are optional.
- * Supplied properties are type-checked against the type of related Model's fields.
- * Relations can be provided in a flexible manner for both many-to-many and foreign key associations
- * @see {@link IdOrModelLike}
- */
-export type UpsertProps<M extends AnyModel> = BlueprintProps<
-    ModelBlueprint<M>,
-    IdKey<M>,
-    Exclude<keyof ModelBlueprint<M>, IdKey<M>>
->;
+    /** @internal */
+    type CustomProps<M extends Model, Props extends object> = Omit<Props, Extract<keyof Props, keyof M>>;
+
+    /** @internal */
+    type ModelBlueprint<
+        M extends Model,
+        K extends keyof M = keyof ExtractClass<M>['fields'] | keyof PickByValue<M, MutableQuerySet>
+    > = {
+        [P in K]: M[P] extends MutableQuerySet<infer RM>
+            ? ReadonlyArray<IdType<RM> | RM>
+            : M[P] extends Model
+            ? IdType<M[P]> | M[P]
+            : M[P];
+    };
 
-/**
- * {@link Model#update} argument type
- *
- * All properties are optional.
- * Supplied properties are type-checked against the type of related Model's fields.
- * Relations can be provided in a flexible manner for both many-to-many and foreign key associations
- * @see {@link IdOrModelLike}
- */
-export type UpdateProps<M extends AnyModel> = BlueprintProps<
-    ModelBlueprint<M>,
-    never,
-    Exclude<keyof ModelBlueprint<M>, IdKey<M>>
->;
+    /** @internal */
+    type BlueprintProps<M, ReqKeys extends keyof M, OptKeys extends keyof M> = {
+        [K in ReqKeys]-?: M[K];
+    } &
+        {
+            [K in OptKeys]+?: M[K];
+        };
+
+    /** {@link Model#create} argument type. */
+    type CreateProps<
+        M extends Model,
+        MB extends ModelBlueprint<M> = ModelBlueprint<M>,
+        MQsKeys extends keyof MB = keyof PickByValue<M, MutableQuerySet>,
+        OptAttrKeys extends keyof MB = FieldDescriptorKeys<M, AttributeWithDefault> | (IdType<M> extends number ? IdKey<M> : never),
+        OptKeys extends keyof MB = MQsKeys | OptionalKeys<M> | OptAttrKeys
+    > = BlueprintProps<MB, Exclude<keyof MB, OptKeys>, OptKeys>;
+
+    /** {@link Model#upsert} argument type */
+    type UpsertProps<M extends Model> = BlueprintProps<
+        ModelBlueprint<M>,
+        IdKey<M>,
+        Exclude<keyof ModelBlueprint<M>, IdKey<M>>
+    >;
+
+    /** {@link Model#update} argument type - all properties aside from the primary key are optional. */
+    type UpdateProps<M extends Model> = BlueprintProps<
+        ModelBlueprint<M>,
+        never,
+        Exclude<keyof ModelBlueprint<M>, IdKey<M>>
+    >;
+
+    /**
+     * {@link ModelOpts} used for {@link Table} customization.
+     *
+     * Supplied via {@link Model#options}.
+     *
+     * If no customizations were provided, the table uses following default options:
+     * <br/>
+     * ```typescript
+     *  {
+     *      idAttribute: 'id',
+     *      arrName:     'items',
+     *      mapName:     'itemsById'
+     *  }
+     * ```
+     * <br/>
+     *  @see {@link Model}
+     *  @see {@link Model#options}
+     *  @see {@link ORM.State}
+     */
+    interface ModelOpts {
+        readonly idAttribute?: string;
+        readonly arrName?: string;
+        readonly mapName?: string;
+    }
+}
 
 export default Model;
diff --git a/types/redux-orm/ORM.d.ts b/types/redux-orm/ORM.d.ts
index 635228f..732cb9b 100644
--- a/types/redux-orm/ORM.d.ts
+++ b/types/redux-orm/ORM.d.ts
@@ -1,5 +1,5 @@
 import createDatabase, { Table, Database } from './db';
-import { AnyModel } from './Model';
+import Model from './Model';
 import Session, { OrmSession } from './Session';
 
 /**
@@ -15,7 +15,7 @@ import Session, { OrmSession } from './Session';
  * Internally, this class handles generating a schema specification from models
  * to the database.
  */
-export class ORM<I extends ORM.IndexedModelClasses<any>, ModelNames extends keyof I = keyof I> {
+export class ORM<S extends ORM.Schema, ORegistry extends ORM.Registry<S> = ORM.Registry<S>> {
     /**
      * Creates a new ORM instance.
      */
@@ -30,7 +30,7 @@ export class ORM<I extends ORM.IndexedModelClasses<any>, ModelNames extends keyo
      *
      * @param  model - a {@link Model} class to register
      */
-    register(...model: ReadonlyArray<I[ModelNames]>): void;
+    register(...model: ReadonlyArray<S[number]>): void;
 
     /**
      * Gets a {@link Model} class by its name from the registry.
@@ -41,40 +41,40 @@ export class ORM<I extends ORM.IndexedModelClasses<any>, ModelNames extends keyo
      *
      * @return the {@link Model} class, if found
      */
-    get<K extends ModelNames>(modelName: K): I[K];
+    get<K extends keyof ORegistry>(modelName: K): ORegistry[K];
 
     /**
      * Returns the empty database state.
      *
-     * @see {@link OrmState}
+     * @see {@link ORM.State}
      *
      * @return empty state
      */
-    getEmptyState(): ORM.OrmState<I>;
+    getEmptyState(): ORM.State<S>;
 
     /**
      * Begins an immutable database session.
      *
-     * @see {@link OrmState}
-     * @see {@link SessionType}
+     * @see {@link ORM.State}
+     * @see {@link OrmSession}
      *
      * @param  state  - the state the database manages
      *
-     * @return a new {@link Session} instance
+     * @return a new {@link OrmSession} instance
      */
-    session(state?: ORM.OrmState<I>): OrmSession<I>;
+    session(state?: ORM.State<S>): OrmSession<S>;
 
     /**
      * Begins an mutable database session.
      *
-     * @see {@link OrmState}
-     * @see {@link SessionType}
+     * @see {@link ORM.State}
+     * @see {@link OrmSession}
      *
      * @param  state  - the state the database manages
      *
-     * @return a new {@link Session} instance
+     * @return a new {@link OrmSession} instance
      */
-    mutableSession(state: ORM.OrmState<I>): OrmSession<I>;
+    mutableSession(state: ORM.State<S>): OrmSession<S>;
 
     /**
      * Acquire database reference.
@@ -83,37 +83,27 @@ export class ORM<I extends ORM.IndexedModelClasses<any>, ModelNames extends keyo
      *
      * @return A {@link Database} instance structured according to registered schema.
      */
-    getDatabase(): Database<I>;
+    getDatabase(): Database<S>;
 }
 
 export namespace ORM {
-    /**
-     * A `{typeof Model[modelName]: typeof Model}` map defining:
-     *
-     * - database schema
-     * - {@link Session} bound Model classes
-     * - ORM branch state type
-     */
-    type IndexedModelClasses<
-        T extends { [k in keyof T]: typeof AnyModel } = {},
-        K extends keyof T = Extract<keyof T, T[keyof T]['modelName']>
-    > = { [k in K]: T[K] };
+    /** ORM instantiation opts - enables customization of database creation. */
+    interface ORMOpts {
+        createDatabase: typeof createDatabase;
+    }
 
-    /**
-     * A mapped type capable of inferring ORM branch state type based on schema {@link Model}s.
-     */
-    type OrmState<MClassMap extends IndexedModelClasses<any>> = {
-        [K in keyof MClassMap]: Table.TableState<MClassMap[K]>
+    /** Schema definition - an array of {@link Model.Class} constructor functions */
+    type Schema = ReadonlyArray<Model.Class>;
+
+    /** A map of schema {@link Model} classes ({@link Model.Class}, indexed by `{@link Model#modelName}` */
+    type Registry<S extends Schema> = {
+        [K in S[number]['modelName']]: Extract<S[number], { modelName: K }>;
     };
 
-    /**
-     * ORM instantiation opts.
-     *
-     * Enables customization of database creation.
-     */
-     interface ORMOpts {
-        createDatabase: typeof createDatabase;
-    }
+    /** A mapped type capable of inferring ORM branch state type based on schema {@link Model.Class} . */
+    type State<S extends Schema> = {
+        [K in keyof Registry<S>]: Table.TableState<Registry<S>[K]>;
+    };
 }
 
 export default ORM;
diff --git a/types/redux-orm/QuerySet.d.ts b/types/redux-orm/QuerySet.d.ts
index 425257a..681f30c 100644
--- a/types/redux-orm/QuerySet.d.ts
+++ b/types/redux-orm/QuerySet.d.ts
@@ -1,8 +1,8 @@
 import { Database } from './db';
-import Model, { AnyModel, IdType, ModelClass, Serializable, SessionBoundModel, UpdateProps } from './Model';
+import Model from './Model';
+import { Serializable } from './helpers';
 
 /**
- * <p>
  * `QuerySet` class is used to build and make queries to the database
  * and operating the resulting set (such as updating attributes
  * or deleting the records).
@@ -15,9 +15,9 @@ import Model, { AnyModel, IdType, ModelClass, Serializable, SessionBoundModel, U
  *
  * @description The query is executed only when terminating operations are invoked, such as:
  *
- * - {@link QuerySet#count},
- * - {@link QuerySet#toRefArray}
- * - {@link QuerySet#at} and other indexed reads
+ * - {@link QuerySet.count},
+ * - {@link QuerySet.toRefArray}
+ * - {@link QuerySet.at} and other indexed reads
  *
  * After the query is executed, the resulting set is cached in the QuerySet instance.
  *
@@ -29,8 +29,34 @@ import Model, { AnyModel, IdType, ModelClass, Serializable, SessionBoundModel, U
  *
  * @see {@link QuerySet.QueryBuilder}
  */
-export class QuerySet<M extends AnyModel = any, InstanceProps extends object = {}>
+export class QuerySet<M extends Model = any, InstanceProps extends Record<string, Serializable> = {}>
     implements QuerySet.QueryBuilder<M, InstanceProps> {
+    /**
+     * Register custom method on a `QuerySet` class specification.
+     * QuerySet class may be attached to a {@link Model} class via {@link Model#querySetClass}
+     *
+     * @param methodName - name of a method to be available on specific QuerySet class instances
+     *
+     * @example:
+     * class CustomQuerySet extends QuerySet<Book> {
+     *     static currentYear = 2019
+     *     unreleased(): QuerySet<Book> {
+     *         return this.filter(book => book.releaseYear > CustomQuerySet.currentYear);
+     *     }
+     * }
+     * CustomQuerySet.addSharedMethod('unreleased');
+     * // assign specific QuerySet to a Model class
+     * Book.querySetClass = typeof CustomQuerySet;
+     * // register models
+     * const schema = {Book };
+     * const orm = new ORM<typeof schema>();
+     * orm.register(Book);
+     * const session = orm.session(orm.getEmptyState());
+     * // use shared method
+     * const unreleased = customQs.unreleased();
+     */
+    static addSharedMethod(methodName: string): void;
+
     /**
      * Creates a `QuerySet`. The constructor is mainly for internal use;
      * Access QuerySet instances from {@link Model}.
@@ -39,7 +65,7 @@ export class QuerySet<M extends AnyModel = any, InstanceProps extends object = {
      * @param  clauses - query clauses needed to evaluate the set.
      * @param  [opts] - additional options
      */
-    constructor(modelClass: ModelClass<M>, clauses: Database.QueryClause[], opts?: object);
+    constructor(modelClass: typeof Model, clauses: Database.QueryClause[], opts?: object);
 
     /**
      * Checks if the {@link QuerySet} instance has any records matching the query
@@ -58,24 +84,17 @@ export class QuerySet<M extends AnyModel = any, InstanceProps extends object = {
     toRefArray(): ReadonlyArray<M['ref'] & InstanceProps>;
 
     /**
-     * Returns an array of {@link SessionBoundModel} instances represented by the QuerySet.
+     * Returns an array of {@link Model} instances represented by the QuerySet.
      *
      * @return session bound model instances represented by the QuerySet
      */
-    toModelArray(): ReadonlyArray<SessionBoundModel<M, InstanceProps>>;
-
-    /**
-     * Returns a string representation of QuerySet instance contents.
-     *
-     * @return string representation of QuerySet.
-     */
-    toString(): string;
+    toModelArray(): ReadonlyArray<M & InstanceProps>;
 
-    at(index: number): SessionBoundModel<M, InstanceProps> | undefined;
+    at(index: number): M & InstanceProps | undefined;
 
-    first(): SessionBoundModel<M, InstanceProps> | undefined;
+    first(): M & InstanceProps | undefined;
 
-    last(): SessionBoundModel<M, InstanceProps> | undefined;
+    last(): M & InstanceProps | undefined;
 
     all(): QuerySet<M, InstanceProps>;
 
@@ -90,79 +109,51 @@ export class QuerySet<M extends AnyModel = any, InstanceProps extends object = {
 
     count(): number;
 
-    update(mergeObj: UpdateProps<M>): void;
+    update(mergeObj: Model.UpdateProps<M>): void;
 
     delete(): void;
 }
 
-/**
- * A {@link QuerySet} extended with {@link ManyToMany} specific functionality.
- */
-export interface MutableQuerySet<M extends AnyModel = any, InstanceProps extends object = {}>
+/** A {@link QuerySet} extended with {@link ManyToMany} specific functionality. */
+export interface MutableQuerySet<M extends Model = any, InstanceProps extends Record<string, Serializable> = {}>
     extends QuerySet<M, InstanceProps> {
-    add: (...entitiesToAdd: Array<IdType<M> | M>) => void;
-    remove: (...entitiesToRemove: Array<IdType<M> | M>) => void;
+    add: (...entitiesToAdd: ReadonlyArray<Model.IdType<M> | M>) => void;
+    remove: (...entitiesToRemove: ReadonlyArray<Model.IdType<M> | M>) => void;
     clear: () => void;
 }
 
 export namespace QuerySet {
-    /**
-     * Register custom method on a `QuerySet` class specification.
-     * QuerySet class may be attached to a {@link Model} class via {@link Model#querySetClass}
-     *
-     * @param methodName - name of a method to be available on specific QuerySet class instances
-     *
-     * @example:
-     * class CustomQuerySet extends QuerySet<Book> {
-     *     static currentYear = 2019
-     *     unreleased(): QuerySet<Book> {
-     *         return this.filter(book => book.releaseYear > CustomQuerySet.currentYear);
-     *     }
-     * }
-     * CustomQuerySet.addSharedMethod('unreleased');
-     * // assign specific QuerySet to a Model class
-     * Book.querySetClass = typeof CustomQuerySet;
-     * // register models
-     * const schema = {Book };
-     * const orm = new ORM<typeof schema>();
-     * orm.register(Book);
-     * const session = orm.session(orm.getEmptyState());
-     * // use shared method
-     * const unreleased = customQs.unreleased();
-     */
-    function addSharedMethod(methodName: string): void;
-
     /**
      * Interface for building queries in fluent style
      */
-    interface QueryBuilder<M extends AnyModel = any, InstanceProps extends object = {}> {
+    interface QueryBuilder<M extends Model = any, InstanceProps extends Record<string, Serializable> = {}> {
         /**
-         * Returns the {@link SessionBoundModel} instance at index `index` in the {@link QuerySet} instance if
+         * Returns the {@link Model} instance at index `index` in the {@link QuerySet} instance if
          * `withRefs` flag is set to `false`, or a reference to the plain JavaScript
          * object in the model state if `true`.
          *
          * @param  index - index of the model instance to get
-         * @return a {@link Model} derived {@link SessionBoundModel} instance at index
+         * @return a {@link Model} derived {@link Model} instance at index
          *                           `index` in the {@link QuerySet} instance,
          *                           or undefined if the index is out of bounds.
          */
-        at(index: number): SessionBoundModel<M, InstanceProps> | undefined;
+        at(index: number): M & InstanceProps | undefined;
 
         /**
          * Returns the session bound {@link Model} instance at index 0
          * in the {@link QuerySet} instance or undefined if the instance is empty.
          *
-         *  @return a {@link Model} derived {@link SessionBoundModel} instance or undefined.
+         *  @return a {@link Model} derived {@link Model} instance or undefined.
          */
-        first(): SessionBoundModel<M, InstanceProps> | undefined;
+        first(): M & InstanceProps | undefined;
 
         /**
          * Returns the session bound {@link Model} instance at index `QuerySet.count() - 1`
          * in the {@link QuerySet} instance or undefined if the instance is empty.
          *
-         *  @return a {@link Model} derived {@link SessionBoundModel} instance or undefined.
+         *  @return a {@link Model} derived {@link Model} instance or undefined.
          */
-        last(): SessionBoundModel<M, InstanceProps> | undefined;
+        last(): M & InstanceProps | undefined;
 
         /**
          * Returns a new {@link QuerySet} instance with the same entities.
@@ -218,7 +209,7 @@ export namespace QuerySet {
          *
          * @param  mergeObj - an object extending {@link UpdateProps}, to be merged with all the objects in this QuerySet.
          */
-        update(mergeObj: UpdateProps<M>): void;
+        update(mergeObj: Model.UpdateProps<M>): void;
 
         /**
          * Records a deletion of all the objects in this {@link QuerySet} instance.
@@ -234,20 +225,20 @@ export namespace QuerySet {
     }
 
     /**
-     * Optional ordering direction.
+     * Ordering clause.
+     *
+     * Either a key of SessionBoundModel or a evaluator function accepting plain object Model representation stored in the database.
      *
      * {@see QuerySet.orderBy}
      */
-    type SortOrder = 'asc' | 'desc' | true | false;
+    type SortIteratee<M extends Model> = keyof M['ref'] | { (row: M['ref']): any };
 
     /**
-     * Ordering clause.
-     *
-     * Either a key of SessionBoundModel or a evaluator function accepting plain object Model representation stored in the database.
+     * Ordering direction.
      *
      * {@see QuerySet.orderBy}
      */
-    type SortIteratee<M extends Model> = keyof M['ref'] | { (row: M['ref']): any };
+    type SortOrder = 'asc' | 'desc' | true | false;
 
     /**
      * Lookup clause as an object specifying props to match with plain object Model representation stored in the database.
@@ -269,14 +260,6 @@ export namespace QuerySet {
      * {@see QuerySet.filter}
      */
     type LookupSpec<M extends Model> = LookupProps<M> | LookupPredicate<M>;
-
-    /**
-     * A lookup query result.
-     *
-     * May contain additional properties in case {@link LookupProps} clause had been supplied.
-     * {@see QuerySet.exclude}
-     * {@see QuerySet.filter}
-     */
 }
 
 export default QuerySet;
diff --git a/types/redux-orm/Session.d.ts b/types/redux-orm/Session.d.ts
index a86ccaf..8c8e347 100644
--- a/types/redux-orm/Session.d.ts
+++ b/types/redux-orm/Session.d.ts
@@ -1,39 +1,35 @@
 import { ORM } from './ORM';
+
+import Model from './Model';
 import { Database } from './db';
 
 export type BatchToken = any;
 
-export default class Session<I extends ORM.IndexedModelClasses<any>> {
+export default class Session<S extends ORM.Schema> {
     /**
      * list of bound {@link Model} classes bound to this session, bootstrapped during {@link @ORM.register}.
      *
      * @see {@link Model}
      */
-    readonly sessionBoundModels: ReadonlyArray<I[keyof I]>;
+    readonly sessionBoundModels: S;
 
     /**
-     * Current {@link OrmState}, specific to registered schema
+     * Current {@link ORM.State}, specific to registered schema
      */
-    readonly state: ORM.OrmState<I>;
+    readonly state: ORM.State<S>;
 
     /**
      * Creates a new Session.
      *
      * @param schema - {@Link ORM} instance, with bootstrapped {@link Model} prototypes.
      * @param  db - a {@link Database} instance
-     * @param  state - the database {@link OrmState}
+     * @param  state - the database {@link ORM.State}
      * @param  withMutations? - whether the session should mutate data
      * @param  batchToken? - a {@link BatchToken} used by the backend to identify objects that can be
      *                                 mutated. If none is provided a default of `Symbol('ownerId')` will be created.
      *
      */
-    constructor(
-        schema: ORM<I>,
-        db: Database<I>,
-        state: ORM.OrmState<I>,
-        withMutations?: boolean,
-        batchToken?: BatchToken
-    );
+    constructor(schema: ORM<S>, db: Database<S>, state: ORM.State<S>, withMutations?: boolean, batchToken?: BatchToken);
 
     /**
      * Executes query against model state.
@@ -54,7 +50,7 @@ export default class Session<I extends ORM.IndexedModelClasses<any>> {
      *
      * @param  update - the update command object.
      *
-     * @returns query result.
+     * @returns applyUpdate result.
      *
      * @see {@link DbAction}
      * @see {@link UpdateSpec}
@@ -70,4 +66,4 @@ export default class Session<I extends ORM.IndexedModelClasses<any>> {
  * Extension is a map of {@link Model} class accessible under keys within a set of {@link Model#modelName} values
  * for registered {@link Model} classes.
  */
-export type OrmSession<I extends ORM.IndexedModelClasses<any>> = Session<I> & I;
+export type OrmSession<S extends ORM.Schema> = Session<S> & ORM.Registry<S>;
diff --git a/types/redux-orm/constants.d.ts b/types/redux-orm/constants.d.ts
index 95654bd..64a1722 100644
--- a/types/redux-orm/constants.d.ts
+++ b/types/redux-orm/constants.d.ts
@@ -1,10 +1,17 @@
-export const UPDATE = 'REDUX_ORM_UPDATE';
-export const DELETE = 'REDUX_ORM_DELETE';
-export const CREATE = 'REDUX_ORM_CREATE';
+export type UPDATE = 'REDUX_ORM_UPDATE';
+export type DELETE = 'REDUX_ORM_DELETE';
+export type CREATE = 'REDUX_ORM_CREATE';
+export type FILTER = 'REDUX_ORM_FILTER';
+export type EXCLUDE = 'REDUX_ORM_EXCLUDE';
+export type ORDER_BY = 'REDUX_ORM_ORDER_BY';
+export type SUCCESS = 'SUCCESS';
+export type FAILURE = 'FAILURE';
 
-export const FILTER = 'REDUX_ORM_FILTER';
-export const EXCLUDE = 'REDUX_ORM_EXCLUDE';
-export const ORDER_BY = 'REDUX_ORM_ORDER_BY';
-
-export const SUCCESS = 'SUCCESS';
-export const FAILURE = 'FAILURE';
+export const UPDATE: UPDATE;
+export const DELETE: DELETE;
+export const CREATE: CREATE;
+export const FILTER: FILTER;
+export const EXCLUDE: EXCLUDE;
+export const ORDER_BY: ORDER_BY;
+export const SUCCESS: SUCCESS;
+export const FAILURE: FAILURE;
diff --git a/types/redux-orm/db/Database.d.ts b/types/redux-orm/db/Database.d.ts
index fd7ed0a..3134110 100644
--- a/types/redux-orm/db/Database.d.ts
+++ b/types/redux-orm/db/Database.d.ts
@@ -1,25 +1,25 @@
 import { ORM } from '../ORM';
 import { CREATE, DELETE, EXCLUDE, FAILURE, FILTER, ORDER_BY, SUCCESS, UPDATE } from '../constants';
 import { Table } from './Table';
-import { Serializable } from '../Model';
+import Model from '../Model';
 import { BatchToken } from '../Session';
+import { Serializable } from '../helpers';
 
 /**
  * A Database parametrized by schema made of {@link Model} classes.
  *
- * @see {@link SchemaSpec}
- * @see {@link TableSpec}
+ * @see {@link Database.SchemaSpec}
  * @see {@link Table}
  */
-export interface Database<I extends ORM.IndexedModelClasses<any>, Tables = { [K in keyof I]: Table<I[K]> }> {
+export interface Database<S extends ORM.Schema> {
     /**
      * Returns the empty database state.
      *
-     * @see {@link OrmState}
+     * @see {@link ORM.State}
      *
      * @return empty state
      */
-    getEmptyState(): ORM.OrmState<I>;
+    getEmptyState(): ORM.State<S>;
 
     /**
      * Execute a query against a given state.
@@ -27,13 +27,13 @@ export interface Database<I extends ORM.IndexedModelClasses<any>, Tables = { [K
      * @param querySpec - a query definition.
      * @param state - the state to query against.
      *
-     * @see {@link QuerySpec}
-     * @see {@link OrmState}
-     * @see {@link OrmState}
+     * @see {@link Database.QuerySpec}
+     * @see {@link Database.QueryResult}
+     * @see {@link ORM.State}
      *
      * @return a {@link QueryResult} containing 0 to many {@link QueryResult.rows}.
      */
-    query(querySpec: Database.QuerySpec, state: ORM.OrmState<I>): Database.QueryResult;
+    query(querySpec: Database.QuerySpec, state: ORM.State<S>): Database.QueryResult;
 
     /**
      * Apply an update to a given state.
@@ -42,14 +42,13 @@ export interface Database<I extends ORM.IndexedModelClasses<any>, Tables = { [K
      * @param tx - a transaction for batches of operations.
      * @param state - the state to apply update to.
      *
-     * @see {@link UpdateSpec}
-     * @see {@link Transaction}
-     * @see {@link OrmState}
+     * @see {@link Database.UpdateSpec}
+     * @see {@link Database.Transaction}
+     * @see {@link ORM.State}
      *
-     * @return a {@link UpdateResult} containing 0 to many {@link QueryResult.rows}.
+     * @return a {@link Database.UpdateResult} containing 0 to many {@link Database.QueryResult.rows}.
      */
-
-    update(updateSpec: Database.UpdateSpec, tx: Database.Transaction, state: ORM.OrmState<I>): Database.UpdateResult<I>;
+    update(updateSpec: Database.UpdateSpec, tx: Database.Transaction, state: ORM.State<S>): Database.UpdateResult<S>;
 
     /**
      * Return a {@link Table} structure based on provided table name.
@@ -57,77 +56,50 @@ export interface Database<I extends ORM.IndexedModelClasses<any>, Tables = { [K
      *
      * @return a {@link Table} instance matching given `tableName` or `undefined` if no such table exists.
      */
-    describe<K extends keyof Tables>(tableName: K): Tables[K];
+    describe<K extends keyof ORM.Registry<S>>(tableName: K): Table<ORM.Registry<S>[K]>;
 }
 
 export namespace Database {
-    /**
-     * A type of {@link QueryClause}.
-     */
-    type QueryType = typeof FILTER | typeof EXCLUDE | typeof ORDER_BY;
-
     /**
      * A single `QueryClause`.
      * Multiple `QueryClause`s can be combined into a {@link Query}.
      */
     interface QueryClause<Payload extends object = {}> {
-        type: QueryType;
+        type: FILTER | EXCLUDE | ORDER_BY;
         payload: Payload;
     }
 
-    /**
-     * Query definition, contains target table and a collection of {@link QueryClause}.
-     */
+    /** Query definition, contains target table and a collection of {@link QueryClause}. */
     interface Query {
         table: string;
         clauses: QueryClause[];
     }
 
-    /**
-     * Query wrapper definition, wraps {@link Query}.
-     */
+    /**  Query wrapper definition, wraps {@link Query}. */
     interface QuerySpec {
         query: Query;
     }
 
-    /**
-     * Query result.
-     */
+    /** Query result. */
     interface QueryResult<Row extends Record<string, Serializable> = {}> {
         rows: ReadonlyArray<Row>;
     }
 
-    /**
-     * A type of data update to perform.
-     */
-    type UpdateType = typeof CREATE | typeof UPDATE | typeof DELETE;
-
-    /**
-     * A status of data update operation.
-     */
-    type UpdateStatus = typeof SUCCESS | typeof FAILURE;
-
-    /**
-     * Data update definition
-     */
+    /** Data update definition */
     interface UpdateSpec<Payload = any> {
-        action: UpdateType;
+        action: CREATE | UPDATE | DELETE;
         payload?: Payload;
         query?: Query;
     }
 
-    /**
-     * Data update result.
-     */
-    interface UpdateResult<I extends ORM.IndexedModelClasses<any>, Payload extends object = {}> {
-        status: UpdateStatus;
-        state: ORM.OrmState<I>;
+    /** Data update result. */
+    interface UpdateResult<S extends ORM.Schema, Payload extends object = {}> {
+        status: SUCCESS | FAILURE;
+        state: ORM.State<S>;
         payload: Payload;
     }
 
-    /**
-     * Transactions aggregate batches of operations.
-     */
+    /** Transactions aggregate batches of operations. */
     interface Transaction {
         batchToken: BatchToken;
         withMutations: boolean;
@@ -136,22 +108,20 @@ export namespace Database {
     /**
      * Schema specification, required for default database creator.
      *
-     * @see {@link DatabaseCreator}
-     * @see {@link ModelTableOpts}
      * @see {@link Table}
+     * @see {@link Table.TableOpts}
+     * @see {@link ORM.Schema}
      */
-    interface SchemaSpec<I extends ORM.IndexedModelClasses<any>> {
-        tables: { [K in keyof I]: Table.ModelTableOpts<I[K]> };
+    interface SchemaSpec<S extends ORM.Schema> {
+        tables: { [K in keyof ORM.Registry<S>]: Table.TableOpts<ORM.Registry<S>[K]> };
     }
 }
-
 /**
  * Default database creation procedure handle.
  *
- * @param schemaSpec - a {@link SchemaSpec} to built the {@link Database} from.
+ * @param schemaSpec - a {@link Database.SchemaSpec} to built the {@link Database} from.
  *
  *  @return a {@Link Database} instance, ready for query and data update operation.
  */
-export function createDatabase<I extends ORM.IndexedModelClasses<any>>(schemaSpec: Database.SchemaSpec<I>): Database<I>;
-
+export function createDatabase<S extends ORM.Schema>(schemaSpec: Database.SchemaSpec<S>): Database<S>;
 export default createDatabase;
diff --git a/types/redux-orm/db/Table.d.ts b/types/redux-orm/db/Table.d.ts
index 26d04e5..a1c8861 100644
--- a/types/redux-orm/db/Table.d.ts
+++ b/types/redux-orm/db/Table.d.ts
@@ -1,11 +1,11 @@
-import Model, { AnyModel, FieldSpecKeys, IdType, Ref } from '../Model';
+import Model from '../Model';
 import { ForeignKey, OneToOne } from '../index';
 import { Field } from '../fields';
 
 /**
  * Handles the underlying data structure for a {@link Model} class.
  */
-export class Table<MClass extends typeof AnyModel> {
+export class Table<MClass extends Model.Class> {
     /**
      * Creates a new {@link Table} instance.
      *
@@ -18,7 +18,7 @@ export class Table<MClass extends typeof AnyModel> {
      *                                                 map.
      * @param   [userOpts.fields=DefaultTableOpts.fields] - mapping of field key to {@link Field} object
      */
-    constructor(userOpts?: Table.ModelTableOpts<MClass>);
+    constructor(userOpts?: Table.TableOpts<MClass>);
 
     getEmptyState(): Table.TableState<MClass>;
 }
@@ -31,8 +31,8 @@ export namespace Table {
         maxId: MIdType extends number ? number : null | number;
     }
 
-    type TableIndexes<MClass extends typeof AnyModel> = {
-        [K in FieldSpecKeys<InstanceType<MClass>, OneToOne | ForeignKey>]: string;
+    type TableIndexes<MClass extends Model.Class> = {
+        [K in Model.FieldDescriptorKeys<InstanceType<MClass>, OneToOne | ForeignKey>]: string;
     };
 
     /**
@@ -40,89 +40,64 @@ export namespace Table {
      *
      * Infers actual state of the ORM branch based on the {@link Model} class provided.
      */
-    type TableState<MClass extends typeof AnyModel> = {
-        readonly meta: DefaultMeta<IdType<InstanceType<MClass>>>;
+    type TableState<MClass extends Model.Class> = {
+        readonly meta: DefaultMeta<Model.IdType<InstanceType<MClass>>>;
         readonly indexes: TableIndexes<MClass>;
-    } & { readonly [K in ArrName<MClass>]: ReadonlyArray<IdType<InstanceType<MClass>>> } &
+    } & { readonly [K in ArrName<MClass>]: ReadonlyArray<Model.IdType<InstanceType<MClass>>> } &
         {
             readonly [K in MapName<MClass>]: {
-                readonly [K: string]: Ref<InstanceType<MClass>>;
+                readonly [K: string]: Model.Ref<InstanceType<MClass>>;
             };
         };
 
-    /**
-     * @internal
-     */
-    type ExtractModelOption<
-        MClass extends typeof AnyModel,
-        K extends keyof TableOpts,
-        DefaultValue extends string
-    > = MClass['options'] extends () => { [P in K]: infer R }
-        ? R extends string
-            ? R
-            : DefaultValue
-        : MClass['options'] extends { [P in K]: infer R }
-        ? R extends string
-            ? R
-            : DefaultValue
-        : DefaultValue;
-
     /**
      * Model idAttribute option extraction helper.
      *
      * Falls back to `'id'` if not specified explicitly via {@link Model.options}.
      */
-    type IdAttribute<MClass extends typeof AnyModel> = ExtractModelOption<MClass, 'idAttribute', 'id'>;
+    type IdAttribute<MClass extends Model.Class> = MClass['options'] extends () => { idAttribute: infer R }
+        ? R
+        : MClass['options'] extends { idAttribute: infer R }
+        ? R
+        : 'id';
 
     /**
      * Model arrName option extraction helper.
      *
      * Falls back to `'items'` if not specified explicitly via {@link Model.options}.
      */
-    type ArrName<MClass extends typeof AnyModel> = ExtractModelOption<MClass, 'arrName', 'items'>;
+    type ArrName<MClass extends Model.Class> = (MClass['options'] extends () => { arrName: infer R }
+        ? R
+        : MClass['options'] extends { arrName: infer R }
+        ? R
+        : 'items') extends infer U
+        ? U extends string
+            ? U
+            : never
+        : never;
 
     /**
      * Model mapName option extraction helper.
      *
      * Falls back to `'itemsById'` if not specified explicitly via {@link Model.options}.
      */
-    type MapName<MClass extends typeof AnyModel> = ExtractModelOption<MClass, 'mapName', 'itemsById'>;
+    type MapName<MClass extends Model.Class> = (MClass['options'] extends () => { mapName: infer R }
+        ? R
+        : MClass['options'] extends { mapName: infer R }
+        ? R
+        : 'itemsById') extends infer U
+        ? U extends string
+            ? U
+            : never
+        : never;
 
     /**
-     * Unbox {@link Model#options} or fallback to default for others.
-     *
      * @internal
      */
-    interface ModelTableOpts<MClass extends typeof AnyModel> {
+    interface TableOpts<MClass extends Model.Class> {
         readonly idAttribute: IdAttribute<MClass>;
         readonly arrName: ArrName<MClass>;
         readonly mapName: MapName<MClass>;
         readonly fields: MClass['fields'];
     }
-
-    /**
-     * {@link TableOpts} used for {@link Table} customization.
-     *
-     * Supplied via {@link Model#options}.
-     *
-     * If no customizations were provided, the table uses following default options:
-     * <br/>
-     * ```typescript
-     *  {
-     *      idAttribute: 'id',
-     *      arrName:     'items',
-     *      mapName:     'itemsById'
-     *  }
-     * ```
-     * <br/>
-     *  @see {@link Model}
-     *  @see {@link Model#options}
-     *  @see {@link OrmState}
-     */
-    interface TableOpts {
-        readonly idAttribute?: string;
-        readonly arrName?: string;
-        readonly mapName?: string;
-        readonly fields?: { [K: string]: Field };
-    }
 }
diff --git a/types/redux-orm/db/index.d.ts b/types/redux-orm/db/index.d.ts
index 4f6bd01..d0435f7 100644
--- a/types/redux-orm/db/index.d.ts
+++ b/types/redux-orm/db/index.d.ts
@@ -1,5 +1,5 @@
-import createDatabase = require('./Database');
+import { createDatabase, Database } from './Database';
 
-export * from './Database';
 export { Table } from './Table';
+export { createDatabase, Database };
 export default createDatabase;
diff --git a/types/redux-orm/fields.d.ts b/types/redux-orm/fields.d.ts
index b8954ee..3c3c4ed 100644
--- a/types/redux-orm/fields.d.ts
+++ b/types/redux-orm/fields.d.ts
@@ -45,34 +45,14 @@ export class ManyToMany extends RelationalField {
     ['type']: 'many';
 }
 
-export interface AttrCreator {
-    (): Attribute;
-    (opts: AttributeOpts): AttributeWithDefault;
-}
-
-export interface FkCreator {
-    (toModelName: string, relatedName?: string): ForeignKey;
-    (opts: RelationalFieldOpts): ForeignKey;
-}
-
-export interface ManyCreator {
-    (toModelName: string, relatedName?: string): ManyToMany;
-    (opts: RelationalFieldOpts): ManyToMany;
-}
+export function attr(opts: AttributeOpts): AttributeWithDefault;
+export function attr(): Attribute;
 
-export interface OneToOneCreator {
-    (toModelName: string, relatedName?: string): OneToOne;
-    (opts: RelationalFieldOpts): OneToOne;
-}
-
-export const attr: AttrCreator;
-
-export const oneToOne: OneToOneCreator;
+export function fk(toModelName: string, relatedName?: string): ForeignKey;
+export function fk(opts: RelationalFieldOpts): ForeignKey;
 
-export const fk: FkCreator;
+export function many(toModelName: string, relatedName?: string): ManyToMany;
+export function many(opts: RelationalFieldOpts): ManyToMany;
 
-export const many: ManyCreator;
-
-export interface FieldSpecMap {
-    [K: string]: Attribute | ForeignKey | ManyToMany | OneToOne;
-}
+export function oneToOne(toModelName: string, relatedName?: string): OneToOne;
+export function oneToOne(opts: RelationalFieldOpts): OneToOne;
diff --git a/types/redux-orm/helpers.d.ts b/types/redux-orm/helpers.d.ts
index 196c6b7..31d34d8 100644
--- a/types/redux-orm/helpers.d.ts
+++ b/types/redux-orm/helpers.d.ts
@@ -1,9 +1,14 @@
+/** Primitive value */
+export type Primitive = (number | string | boolean | undefined) | Array<number | string | boolean | undefined>;
+
+/** Plain JS object */
+export interface PlainObject {
+    [K: string]: Serializable;
+}
+
+/** Serializable value: a {@link Primitive}, a {@link PlainObject} or an `Array<PlainObject>` */
+export type Serializable = Primitive | PlainObject | PlainObject[];
+
 export type PickByValue<T, ValueType> = Pick<T, { [Key in keyof T]: T[Key] extends ValueType ? Key : never }[keyof T]>;
 
 export type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];
-
-export type KnownKeys<T> = {
-    [K in keyof T]: string extends K ? never : number extends K ? never : K;
-} extends { [_ in keyof T]: infer U }
-    ? U
-    : never;
diff --git a/types/redux-orm/index.d.ts b/types/redux-orm/index.d.ts
index 17e43f6..d1b47ae 100644
--- a/types/redux-orm/index.d.ts
+++ b/types/redux-orm/index.d.ts
@@ -5,60 +5,12 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 3.5
 
-import { ORM } from './ORM';
-import Model, {
-    CreateProps,
-    CustomInstanceProps,
-    IdKey,
-    IdOrModelLike,
-    IdType,
-    ModelField,
-    ModelFieldMap,
-    Ref,
-    RefPropOrSimple,
-    SessionBoundModel,
-    UpdateProps,
-    UpsertProps
-} from './Model';
-import QuerySet, { MutableQuerySet } from './QuerySet';
-import { OrmSession } from './Session';
-import { createDatabase } from './db';
-import { attr, Attribute, FieldSpecMap, fk, ForeignKey, many, ManyToMany, OneToOne, oneToOne } from './fields';
-import { createReducer, createSelector, defaultUpdater, ORMReducer, ORMSelector } from './redux';
-
-export {
-    FieldSpecMap,
-    RefPropOrSimple,
-    ModelFieldMap,
-    CustomInstanceProps,
-    UpsertProps,
-    CreateProps,
-    UpdateProps,
-    ModelField,
-    OrmSession as Session,
-    MutableQuerySet,
-    createDatabase,
-    createSelector,
-    createReducer,
-    defaultUpdater,
-    ORMSelector,
-    ORMReducer,
-    IdOrModelLike,
-    Ref,
-    SessionBoundModel,
-    IdKey,
-    IdType,
-    ORM,
-    Model,
-    QuerySet,
-    Attribute,
-    OneToOne,
-    ForeignKey,
-    ManyToMany,
-    attr,
-    oneToOne,
-    fk,
-    many
-};
+export { ORM } from './ORM';
+export { Model } from './Model';
+export { OrmSession as Session } from './Session';
+export { createDatabase } from './db';
+export { attr, Attribute, fk, ForeignKey, many, ManyToMany, OneToOne, oneToOne } from './fields';
+export { createReducer, createSelector } from './redux';
 
-export default Model;
+import QuerySet, { MutableQuerySet } from './QuerySet';
+export { MutableQuerySet, QuerySet };
diff --git a/types/redux-orm/redux-orm-tests.ts b/types/redux-orm/redux-orm-tests.ts
index ba0f6bb..0269d12 100644
--- a/types/redux-orm/redux-orm-tests.ts
+++ b/types/redux-orm/redux-orm-tests.ts
@@ -1,16 +1,4 @@
-import {
-    attr,
-    createSelector as createOrmSelector,
-    fk,
-    IdKey,
-    IdType,
-    many,
-    Model,
-    MutableQuerySet,
-    ORM,
-    QuerySet,
-    Ref
-} from 'redux-orm';
+import { createSelector as createOrmSelector, attr, fk, many, Model, MutableQuerySet, ORM, QuerySet } from 'redux-orm';
 
 interface CreateBookAction {
     type: 'CREATE_BOOK';
@@ -24,14 +12,14 @@ interface DeleteBookAction {
 
 type RootAction = CreateBookAction | DeleteBookAction;
 
-interface BookFields {
+interface Book {
     title: string;
     coverArt: string;
     publisher: Publisher;
     authors: MutableQuerySet<Person>;
 }
 
-class Book extends Model<typeof Book, BookFields> {
+class Book extends Model<typeof Book> {
     static modelName = 'Book' as const;
     static fields = {
         title: attr(),
@@ -48,7 +36,7 @@ class Book extends Model<typeof Book, BookFields> {
                 book.create(action.payload);
                 break;
             case 'DELETE_BOOK':
-                book.filter(book => book.title === action.payload.title).delete();
+                book.withId(action.payload.title)!.delete();
                 break;
             default:
                 break;
@@ -56,7 +44,7 @@ class Book extends Model<typeof Book, BookFields> {
     }
 }
 
-interface PersonFields {
+interface Person {
     id: string;
     firstName: string;
     lastName: string;
@@ -64,7 +52,7 @@ interface PersonFields {
     books: MutableQuerySet<Book>;
 }
 
-class Person extends Model<typeof Person, PersonFields> {
+class Person extends Model<typeof Person> {
     static modelName = 'Person' as const;
     static fields = {
         id: attr(),
@@ -74,14 +62,14 @@ class Person extends Model<typeof Person, PersonFields> {
     };
 }
 
-interface AuthorshipFields {
+interface Authorship {
     id: number;
     year?: number;
     book: Book;
     author: Person;
 }
 
-class Authorship extends Model<typeof Authorship, AuthorshipFields> {
+class Authorship extends Model<typeof Authorship> {
     static modelName = 'Authorship' as const;
     static fields = {
         year: attr(),
@@ -90,13 +78,13 @@ class Authorship extends Model<typeof Authorship, AuthorshipFields> {
     };
 }
 
-interface PublisherFields {
+interface Publisher {
     index: number;
     name: string;
     books: QuerySet<Book>;
 }
 
-class Publisher extends Model<typeof Publisher, PublisherFields> {
+class Publisher extends Model<typeof Publisher> {
     static modelName = 'Publisher' as const;
     static fields = {
         index: attr(),
@@ -107,9 +95,7 @@ class Publisher extends Model<typeof Publisher, PublisherFields> {
     };
 }
 
-const schema = { Book, Authorship, Person, Publisher };
-
-type Schema = typeof schema;
+type Schema = [typeof Book, typeof Authorship, typeof Person, typeof Publisher];
 
 // create ORM instance and register { Book, Publisher, Person, Authorship } schema
 const ormFixture = () => {
@@ -197,7 +183,7 @@ const sessionFixture = () => {
     /** Upsert requires id to be provided */
     Book.upsert({ publisher: 1 }); // $ExpectError
 
-    // $ExpectType SessionBoundModel<Book, Pick<{ title: string; publisher: number; }, never>>
+    // $ExpectType Book & Pick<{ title: string; publisher: number; }, never>
     Book.upsert({ title: 'B1', publisher: 1 });
 
     /* Incompatible property types: */
@@ -231,8 +217,7 @@ const sessionFixture = () => {
 
 // restriction of allowed ORM.register args
 (() => {
-    const incompleteSchema = { Book, Authorship, Person };
-    const orm = new ORM<typeof incompleteSchema>();
+    const orm = new ORM<[typeof Book, typeof Authorship, typeof Person]>();
     orm.register(Book, Authorship, Person, Publisher); // $ExpectError
 })();
 
@@ -257,9 +242,8 @@ const sessionFixture = () => {
 
 // IdKey and IdType mapped types support for valid identifier configurations
 (() => {
-    type ExtractId<M extends Model> = [IdKey<M>, IdType<M>];
+    type ExtractId<M extends Model> = [Model.IdKey<M>, Model.IdType<M>];
 
-    type ImplicitDefault = ExtractId<Authorship>; // $ExpectType ["id", number]
     type CustomKey = ExtractId<Publisher>; // $ExpectType ["index", number]
     type CustomType = ExtractId<Person>; // $ExpectType ["id", string]
     type CustomKeyAndType = ExtractId<Book>; // $ExpectType ["title", string]
@@ -293,7 +277,7 @@ const sessionFixture = () => {
 (() => {
     const orm = ormFixture();
 
-    type StateType = ORM.OrmState<Schema>;
+    type StateType = ORM.State<Schema>;
 
     return (state: StateType, action: CreateBookAction): StateType => {
         const session = orm.session(state);
@@ -341,7 +325,7 @@ const sessionFixture = () => {
 // selectors
 (() => {
     // test fixture, use reselect.createSelector in production code
-    const createSelector = <S, OS extends ORM.OrmState<any>, Result extends any>(
+    const createSelector = <S, OS extends ORM.State<any>, Result extends any>(
         param1Creator: (state: S) => OS,
         combiner: (param1: OS) => Result
     ): ((state: S) => Result) => state => combiner(param1Creator(state));
@@ -351,20 +335,20 @@ const sessionFixture = () => {
     const ormSelector = createOrmSelector(orm, session => session.Book.all().toRefArray()[0]);
 
     interface RootState {
-        db: ORM.OrmState<Schema>;
+        db: ORM.State<Schema>;
     }
 
-    const selector = createSelector<RootState, ORM.OrmState<Schema>, Ref<Book>>(
+    const selector = createSelector<RootState, ORM.State<Schema>, Model.Ref<Book>>(
         ({ db }) => db,
         ormSelector
     );
 
-    createSelector<RootState, ORM.OrmState<Schema>, Ref<Person>>(
+    selector({ db: orm.getEmptyState() }); // $ExpectType Ref<Book>
+
+    return createSelector<RootState, ORM.State<Schema>, Model.Ref<Person>>(
         ({ db }) => db,
         ormSelector // $ExpectError
     );
-
-    selector({ db: orm.getEmptyState() }); // $ExpectType Ref<Book>
 })();
 
 // advanced selectors
@@ -374,10 +358,10 @@ const sessionFixture = () => {
     interface RootState {
         foo: number;
         bar: string;
-        db: ORM.OrmState<Schema>;
+        db: ORM.State<Schema>;
     }
 
-    type TestSelector = (state: RootState) => Ref<Book>;
+    type TestSelector = (state: RootState) => Model.Ref<Book>;
 
     const selector0 = createOrmSelector(orm, s => s.db, session => session.Book.first()!.ref) as TestSelector;
 
diff --git a/types/redux-orm/redux.d.ts b/types/redux-orm/redux.d.ts
index bd0c7c3..7da9357 100644
--- a/types/redux-orm/redux.d.ts
+++ b/types/redux-orm/redux.d.ts
@@ -1,87 +1,87 @@
 import { ORM } from './ORM';
 import { OrmSession } from './Session';
 
-export interface ORMReducer<I extends ORM.IndexedModelClasses, TAction extends any = any> {
-    (state: ORM.OrmState<I> | undefined, action: TAction): ORM.OrmState<I>;
+export interface ORMReducer<S extends ORM.Schema, TAction extends any = any> {
+    (state: ORM.State<S> | undefined, action: TAction): ORM.State<S>;
 }
 
-export type defaultUpdater<I extends ORM.IndexedModelClasses, TAction extends any = any> = (
-    session: OrmSession<I>,
+export type defaultUpdater<S extends ORM.Schema, TAction extends any = any> = (
+    session: OrmSession<S>,
     action: TAction
 ) => void;
 
-export function createReducer<I extends ORM.IndexedModelClasses, TAction extends any = any>(
-    orm: ORM<I>,
-    updater?: defaultUpdater<I, TAction>
-): ORMReducer<I, TAction>;
+export function createReducer<S extends ORM.Schema, TAction extends any = any>(
+    orm: ORM<S>,
+    updater?: defaultUpdater<S, TAction>
+): ORMReducer<S, TAction>;
 
 export type Selector<S, R> = (state: S) => R;
 
-export interface ORMSelector<I extends ORM.IndexedModelClasses, Args extends any[], R> {
-    (session: OrmSession<I>, ...args: Args): R;
+export interface ORMSelector<S extends ORM.Schema, Args extends any[], R> {
+    (session: OrmSession<S>, ...args: Args): R;
 }
 
-export function createSelector<S, I, R1, R2, R3, R4, R5, R6, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R2, R3, R4, R5, R6, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
     selector2: Selector<S, R2>,
     selector3: Selector<S, R3>,
     selector4: Selector<S, R4>,
     selector5: Selector<S, R5>,
     selector6: Selector<S, R6>,
-    ormSelector: ORMSelector<I, [R1, R2, R3, R4, R5, R6], R>
+    ormSelector: ORMSelector<OSchema, [R1, R2, R3, R4, R5, R6], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R1, R2, R3, R4, R5, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R2, R3, R4, R5, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
     selector2: Selector<S, R2>,
     selector3: Selector<S, R3>,
     selector4: Selector<S, R4>,
     selector5: Selector<S, R5>,
-    ormSelector: ORMSelector<I, [R1, R2, R3, R4, R5], R>
+    ormSelector: ORMSelector<OSchema, [R1, R2, R3, R4, R5], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R1, R2, R3, R4, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R2, R3, R4, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
     selector2: Selector<S, R2>,
     selector3: Selector<S, R3>,
     selector4: Selector<S, R4>,
-    ormSelector: ORMSelector<I, [R1, R2, R3, R4], R>
+    ormSelector: ORMSelector<OSchema, [R1, R2, R3, R4], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R1, R2, R3, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R2, R3, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
     selector2: Selector<S, R2>,
     selector3: Selector<S, R3>,
-    ormSelector: ORMSelector<I, [R1, R2, R3], R>
+    ormSelector: ORMSelector<OSchema, [R1, R2, R3], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R1, R2, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R2, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
     selector2: Selector<S, R2>,
-    ormSelector: ORMSelector<I, [R1, R2], R>
+    ormSelector: ORMSelector<OSchema, [R1, R2], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R1, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
+export function createSelector<S, OSchema extends ORM.Schema, R1, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
     selector1: Selector<S, R1>,
-    ormSelector: ORMSelector<I, [R1], R>
+    ormSelector: ORMSelector<OSchema, [R1], R>
 ): Selector<S, R>;
 
-export function createSelector<S, I, R>(
-    orm: ORM<I>,
-    OrmStateSelector: Selector<S, ORM.OrmState<I>>,
-    ormSelector: ORMSelector<I, [], R>
+export function createSelector<S, OSchema extends ORM.Schema, R>(
+    orm: ORM<OSchema>,
+    OrmStateSelector: Selector<S, ORM.State<OSchema>>,
+    ormSelector: ORMSelector<OSchema, [], R>
 ): Selector<S, R>;
 
-export function createSelector<I, R>(orm: ORM<I>, ormSelector: ORMSelector<I, [], R>): Selector<ORM.OrmState<I>, R>;
+export function createSelector<OSchema extends ORM.Schema, R>(orm: ORM<OSchema>, ormSelector: ORMSelector<OSchema, [], R>): Selector<ORM.State<OSchema>, R>;