@radio-garden/rematch 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,543 @@
+import { ActionCreator, Action, Middleware, StoreCreator, compose, StoreEnhancer } from 'redux';
+import { createSelector } from 'reselect';
+
+interface DevToolOptions {
+    /**
+     * the instance name to be showed on the monitor page. Default value is `document.title`.
+     * If not specified and there's no document title, it will consist of `tabId` and `instanceId`.
+     */
+    name?: string;
+    /**
+     * action creators functions to be available in the Dispatcher.
+     */
+    actionCreators?: ActionCreator<any>[] | {
+        [key: string]: ActionCreator<any>;
+    };
+    /**
+     * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.
+     * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.
+     * Set it to a higher value when experiencing perf issues (also `maxAge` to a lower value).
+     *
+     * @default 500 ms.
+     */
+    latency?: number;
+    /**
+     * (> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.
+     *
+     * @default 50
+     */
+    maxAge?: number;
+    /**
+     * Customizes how actions and state are serialized and deserialized. Can be a boolean or object. If given a boolean, the behavior is the same as if you
+     * were to pass an object and specify `options` as a boolean. Giving an object allows fine-grained customization using the `replacer` and `reviver`
+     * functions.
+     */
+    serialize?: boolean | {
+        /**
+         * - `undefined` - will use regular `JSON.stringify` to send data (it's the fast mode).
+         * - `false` - will handle also circular references.
+         * - `true` - will handle also date, regex, undefined, error objects, symbols, maps, sets and functions.
+         * - object, which contains `date`, `regex`, `undefined`, `error`, `symbol`, `map`, `set` and `function` keys.
+         *   For each of them you can indicate if to include (by setting as `true`).
+         *   For `function` key you can also specify a custom function which handles serialization.
+         *   See [`jsan`](https://github.com/kolodny/jsan) for more details.
+         */
+        options?: undefined | boolean | {
+            date?: true;
+            regex?: true;
+            undefined?: true;
+            error?: true;
+            symbol?: true;
+            map?: true;
+            set?: true;
+            function?: true | ((fn: (...args: any[]) => any) => string);
+        };
+        /**
+         * [JSON replacer function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter) used for both actions and states stringify.
+         * In addition, you can specify a data type by adding a [`__serializedType__`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/helpers/index.js#L4)
+         * key. So you can deserialize it back while importing or persisting data.
+         * Moreover, it will also [show a nice preview showing the provided custom type](https://cloud.githubusercontent.com/assets/7957859/21814330/a17d556a-d761-11e6-85ef-159dd12f36c5.png):
+         */
+        replacer?: (key: string, value: unknown) => any;
+        /**
+         * [JSON `reviver` function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter)
+         * used for parsing the imported actions and states. See [`remotedev-serialize`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/immutable/serialize.js#L8-L41)
+         * as an example on how to serialize special data types and get them back.
+         */
+        reviver?: (key: string, value: unknown) => any;
+        /**
+         * Automatically serialize/deserialize immutablejs via [remotedev-serialize](https://github.com/zalmoxisus/remotedev-serialize).
+         * Just pass the Immutable library. It will support all ImmutableJS structures. You can even export them into a file and get them back.
+         * The only exception is `Record` class, for which you should pass this in addition the references to your classes in `refs`.
+         */
+        immutable?: any;
+        /**
+         * ImmutableJS `Record` classes used to make possible restore its instances back when importing, persisting...
+         */
+        refs?: any;
+    };
+    /**
+     * function which takes `action` object and id number as arguments, and should return `action` object back.
+     */
+    actionSanitizer?: <A extends Action>(action: A, id: number) => A;
+    /**
+     * function which takes `state` object and index as arguments, and should return `state` object back.
+     */
+    stateSanitizer?: <S>(state: S, index: number) => S;
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsDenylist?: string | string[];
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsAllowlist?: string | string[];
+    /**
+     * called for every action before sending, takes `state` and `action` object, and returns `true` in case it allows sending the current data to the monitor.
+     * Use it as a more advanced version of `actionsDenylist`/`actionsAllowlist` parameters.
+     */
+    predicate?: <S, A extends Action>(state: S, action: A) => boolean;
+    /**
+     * if specified as `false`, it will not record the changes till clicking on `Start recording` button.
+     * Available only for Redux enhancer, for others use `autoPause`.
+     *
+     * @default true
+     */
+    shouldRecordChanges?: boolean;
+    /**
+     * if specified, whenever clicking on `Pause recording` button and there are actions in the history log, will add this action type.
+     * If not specified, will commit when paused. Available only for Redux enhancer.
+     *
+     * @default "@@PAUSED""
+     */
+    pauseActionType?: string;
+    /**
+     * auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.
+     * Not available for Redux enhancer (as it already does it but storing the data to be sent).
+     *
+     * @default false
+     */
+    autoPause?: boolean;
+    /**
+     * if specified as `true`, it will not allow any non-monitor actions to be dispatched till clicking on `Unlock changes` button.
+     * Available only for Redux enhancer.
+     *
+     * @default false
+     */
+    shouldStartLocked?: boolean;
+    /**
+     * if set to `false`, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.
+     *
+     * @default true
+     */
+    shouldHotReload?: boolean;
+    /**
+     * if specified as `true`, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.
+     *
+     * @default false
+     */
+    shouldCatchErrors?: boolean;
+    /**
+     * If you want to restrict the extension, specify the features you allow.
+     * If not specified, all of the features are enabled. When set as an object, only those included as `true` will be allowed.
+     * Note that except `true`/`false`, `import` and `export` can be set as `custom` (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side.
+     * Otherwise, you'll get/set the data right from the monitor part.
+     */
+    features?: {
+        /**
+         * start/pause recording of dispatched actions
+         */
+        pause?: boolean;
+        /**
+         * lock/unlock dispatching actions and side effects
+         */
+        lock?: boolean;
+        /**
+         * persist states on page reloading
+         */
+        persist?: boolean;
+        /**
+         * export history of actions in a file
+         */
+        export?: boolean | 'custom';
+        /**
+         * import history of actions from a file
+         */
+        import?: boolean | 'custom';
+        /**
+         * jump back and forth (time travelling)
+         */
+        jump?: boolean;
+        /**
+         * skip (cancel) actions
+         */
+        skip?: boolean;
+        /**
+         * drag and drop actions in the history list
+         */
+        reorder?: boolean;
+        /**
+         * dispatch custom actions or action creators
+         */
+        dispatch?: boolean;
+        /**
+         * generate tests for the selected actions
+         */
+        test?: boolean;
+    };
+    /**
+     * Set to true or a stacktrace-returning function to record call stack traces for dispatched actions.
+     * Defaults to false.
+     */
+    trace?: boolean | (<A extends Action>(action: A) => string);
+    /**
+     * The maximum number of stack trace entries to record per action. Defaults to 10.
+     */
+    traceLimit?: number;
+}
+declare global {
+    interface Window {
+        __REDUX_DEVTOOLS_EXTENSION_COMPOSE__?: any;
+    }
+}
+
+/**
+ * Utility type taken by type-fest repository
+ * https://github.com/sindresorhus/type-fest/blob/main/source/merge-exclusive.d.ts
+ * Merges Exclusively two types into one
+ * Used to fix this https://github.com/rematch/rematch/issues/912
+ */
+type Without<FirstType, SecondType> = {
+    [KeyType in Exclude<keyof FirstType, keyof SecondType>]: never;
+};
+type MergeExclusive<FirstType, SecondType> = FirstType | SecondType extends object ? (Without<FirstType, SecondType> & SecondType) | (Without<SecondType, FirstType> & FirstType) : FirstType | SecondType;
+/**
+ * Custom Action interface, adds an additional field - `payload`.
+ *
+ * Strings (instead of Symbols) are used as the type for `type` field inherited
+ * from Redux, because strings are serializable.
+ *
+ * @template TPayload The type of the action's payload.
+ */
+interface RematchAction<TPayload = any, TMeta = any> extends Action<string> {
+    payload?: TPayload;
+    meta?: TMeta;
+}
+/**
+ * Custom reducer which instead of an action (like in Redux), accepts payload as
+ * as a second argument.
+ *
+ * @template TState The type of state consumed and produced by this reducer.
+ */
+type Reducer<TState = any> = (state: TState, payload?: RematchAction['payload'], meta?: RematchAction['meta']) => TState;
+/** ************************** Model *************************** */
+/**
+ * Mapping from a model key to model object.
+ *
+ * @template TModels List of all models
+ */
+interface Models<TModels extends Models<TModels>> {
+    [key: string]: Model<TModels>;
+}
+interface NamedModel<TModels extends Models<TModels>, TState = any> extends Model<TModels, TState> {
+    name: string;
+    reducers: ModelReducers<TState>;
+}
+interface Model<TModels extends Models<TModels>, TState = any> {
+    name?: string;
+    state: TState;
+    reducers?: ModelReducers<TState>;
+    effects?: ModelEffects<TModels> | ModelEffectsCreator<TModels>;
+    selectors?: ModelSelectorsCreator<TModels>;
+}
+type ModelSelectors<TModels extends Models<TModels>> = {
+    [key: string]: (state: ExtractRematchStateFromModels<TModels>) => any;
+};
+type ModelSelectorsCreator<TModels extends Models<TModels>> = (store: RematchStore<TModels>) => ModelSelectors<TModels>;
+type ModelReducers<TState = any> = {
+    [key: string]: Reducer<TState>;
+};
+interface ModelEffects<TModels extends Models<TModels>> {
+    [key: string]: ModelEffect<TModels>;
+}
+type ModelEffectThisTyped = {
+    [key: string]: (payload?: any, meta?: any) => RematchAction<any, any>;
+};
+type ModelEffect<TModels extends Models<TModels>> = (this: ModelEffectThisTyped, payload: RematchAction['payload'], rootState: RematchRootState<TModels>, meta: RematchAction['meta']) => any;
+type ModelEffectsCreator<TModels extends Models<TModels>> = (store: RematchStore<TModels>) => ModelEffects<TModels>;
+type ExposedFunction<TModels extends Models<TModels>> = (rematch: RematchStore<TModels>, ...args: any) => any;
+/** ************************** Rematch *************************** */
+/**
+ * Initial, optional configuration provided by the user which describes how
+ * Rematch store should be configured.
+ */
+interface InitConfig<TModels extends Models<TModels>> {
+    name?: string;
+    models?: TModels | Partial<TModels>;
+    redux?: InitConfigRedux;
+}
+/**
+ * Config created out of the InitConfig by filling in missing properties with
+ * default values
+ */
+interface Config<TModels extends Models<TModels>> extends InitConfig<TModels> {
+    name: string;
+    models: TModels | Partial<TModels>;
+    redux: ConfigRedux;
+}
+/** ************************** Rematch-Redux *************************** */
+/**
+ * Initial, optional configuration for Redux, provided by the user. It allows
+ * to gain full control over the way Redux is configured by Rematch and
+ * override any defaults.
+ */
+interface InitConfigRedux {
+    middlewares?: Middleware[];
+    createStore?: StoreCreator | undefined;
+    devtoolOptions?: DevToolOptions & {
+        disabled?: boolean;
+    };
+    /**
+     * Custom compose function for DevTools integration.
+     * Use this for React Native with Flipper or Reactotron.
+     * If not provided, browser Redux DevTools Extension is auto-detected.
+     */
+    devtoolCompose?: (options?: DevToolOptions) => typeof compose;
+}
+/**
+ * Config created out of InitConfigRedux by supplying default values in place
+ * of missing properties.
+ */
+interface ConfigRedux extends InitConfigRedux {
+    enhancers: StoreEnhancer[];
+    middlewares: Middleware[];
+}
+type OmitIndexSignature<T> = {
+    [K in keyof T as K extends string ? K : never]: T[K];
+};
+type WithoutParametersObject<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => infer R ? () => R : T;
+};
+type ExtractModelSelectors<TSelectors extends Model<TModels>['selectors'], TModels extends Models<TModels>> = TSelectors extends ModelSelectorsCreator<TModels> ? ReturnType<TSelectors> : object;
+interface RematchStore<TModels extends Models<TModels>, RootState = OmitIndexSignature<{
+    [modelKey in keyof TModels]: TModels[modelKey]['state'];
+}>> {
+    name: string;
+    dispatch: RematchDispatch<TModels>;
+    getState: () => RematchRootState<TModels>;
+    createSelector: <T extends ReturnType<typeof createSelector.withTypes<RematchRootState<TModels>>>, S extends (create: T) => ReturnType<T>>(callback: S) => ReturnType<S>;
+    selector: {
+        [K in keyof TModels]: ((state: RootState) => TModels[K]['state']) & Required<{
+            [P in keyof TModels[K]['state']]: (state: RootState) => TModels[K]['state'][P];
+        }> & ExtractModelSelectors<TModels[K]['selectors'], TModels>;
+    };
+    select: {
+        [K in keyof TModels]: (() => TModels[K]['state']) & Required<{
+            [P in keyof TModels[K]['state']]: () => TModels[K]['state'][P];
+        }> & WithoutParametersObject<ExtractModelSelectors<TModels[K]['selectors'], TModels>>;
+    };
+    /**
+     * Watches one or more selectors for changes and triggers a callback when their values change.
+     *
+     * @template T - Type of the selector function
+     *
+     * @param selector - A single selector function or array of selector functions to watch
+     * @param onChange - Callback function that receives new and old values when state changes
+     * @param options - Configuration options
+     * @param options.initial - If true, the onChange callback will be called in the next event loop tick
+     * with the current value of the selector and also the current value for the previous state.
+     *
+     * @returns Unsubscribe function to stop watching
+     *
+     * @example
+     * // Watch a single selector
+     * const unsubscribe1 = store.watchSelector(
+     *   (state) => state.users.currentUser,
+     *   (newUser, oldUser) => {
+     *     console.log('User changed from', oldUser, 'to', newUser);
+     *   }
+     * );
+     *
+     * // Watch multiple selectors
+     * const unsubscribe2 = store.watchSelector(
+     *   [
+     *     (state) => state.users.currentUser,
+     *     (state) => state.posts.recentPosts
+     *   ],
+     *   ([newUser, newPosts], [oldUser, oldPosts]) => {
+     *     // Handle changes to either user or posts
+     *   },
+     *   { initial: true }
+     * );
+     *
+     * // Later: stop watching
+     * unsubscribe1();
+     * unsubscribe2();
+     */
+    watchSelector<T extends (state: ExtractRematchStateFromModels<TModels>) => any, const TSelectors extends T[], TReturnValues extends {
+        [T in keyof TSelectors]: ReturnType<TSelectors[T]>;
+    }>(selector: TSelectors, onChange: (newValue: TReturnValues, oldValue: TReturnValues) => void | Promise<void>, options?: {
+        initial?: boolean;
+    }): () => void;
+    watchSelector<T extends (state: ExtractRematchStateFromModels<TModels>) => any>(selector: T, onChange: (newValue: ReturnType<T>, oldValue: ReturnType<T>) => void | Promise<void>, options?: {
+        initial?: boolean;
+    }): () => void;
+    /**
+     * Subscribes to store state changes. This is the underlying Redux subscribe method.
+     *
+     * @param listener - Callback function that will be called whenever state changes
+     * @returns Unsubscribe function to stop listening
+     */
+    subscribe(listener: () => void): () => void;
+}
+/** ************************** Root State *************************** */
+/**
+ * The type of state held by a store.
+ */
+type RematchRootState<TModels extends Models<TModels> = Record<string, never>> = ExtractRematchStateFromModels<TModels>;
+/**
+ * A mapping from each model's name to a type of state it holds.
+ */
+type ExtractRematchStateFromModels<TModels extends Models<TModels>> = {
+    [modelKey in keyof TModels]: TModels[modelKey]['state'];
+};
+/** ************************** Dispatch *************************** */
+/**
+ * Rematch dispatch is a combination of regular redux dispatch method and
+ * an object allowing to dispatch specific actions by calling it the form of
+ * dispatch[modelName][reducerName | effectName](payload).
+ */
+type RematchDispatch<TModels extends Models<TModels>> = ExtractRematchDispatchersFromModels<TModels>;
+/**
+ * Goes over all models and extracts from each a type for dispatcher object
+ * created by Rematch.
+ */
+type ExtractRematchDispatchersFromModels<TModels extends Models<TModels>> = {
+    [modelKey in keyof TModels]: TModels[modelKey] extends Model<TModels> ? ModelDispatcher<TModels[modelKey], TModels> : never;
+};
+/**
+ * Combines together types extracted from reducers and effects for a model.
+ */
+type ModelDispatcher<TModel extends Model<TModels>, TModels extends Models<TModels>> = MergeExclusive<ExtractRematchDispatchersFromEffects<TModel['effects'], TModels>, ExtractRematchDispatchersFromReducers<TModel['state'], TModel['reducers'], TModels>>;
+/**
+ * Get return type of rematch dispatcher
+ */
+type ReturnOfDispatcher<IsEffect extends boolean, TParam extends unknown[] = [], TReturn = any> = IsEffect extends true ? TReturn : RematchAction<TParam[0], TParam[1]>;
+/**
+ * When `TParam` is of type empty array, it describes 'empty' dispatcher - meaning
+ * it's a function not taking any arguments and returning an action.
+ * Otherwise, it describes dispatcher which accepts two optional argument (payload/meta)
+ * and returns an action.
+ */
+type RematchDispatcher<IsEffect extends boolean, TParam extends unknown[] = [], TReturn = any> = ((...args: TParam) => ReturnOfDispatcher<IsEffect, TParam, TReturn>) & {
+    isEffect: IsEffect;
+};
+/** ************************ Reducers Dispatcher ************************* */
+/**
+ * Utility type used to extract the `[payload?, meta?]` parameters type
+ * from reducer parameters.
+ */
+type ExtractParametersFromReducer<P extends unknown[]> = P extends [] ? [] : P extends [p?: infer TPayload] ? P extends [infer TPayloadMayUndefined] ? [p: TPayloadMayUndefined] : [p?: TPayload] : P extends [p?: infer TPayload, m?: infer TMeta, ...args: unknown[]] ? P extends [
+    infer TPayloadMayUndefined,
+    infer TMetaMayUndefined,
+    ...unknown[]
+] ? [p: TPayloadMayUndefined, m: TMetaMayUndefined] : P extends [infer TPayloadMayUndefined, unknown?, ...unknown[]] ? [p: TPayloadMayUndefined, m?: TMeta] : [p?: TPayload, m?: TMeta] : [];
+/**
+ * Extracts a dispatcher for each reducer that is defined for a model.
+ */
+type ExtractRematchDispatchersFromReducers<TState, TReducers extends Model<TModels, TState>['reducers'], TModels extends Models<TModels>> = {
+    [reducerKey in keyof TReducers]: ExtractRematchDispatcherFromReducer<TState, TReducers[reducerKey]>;
+};
+/**
+ * Matches a reducer to different forms and based on the form, selects an
+ * appropriate type for a dispatcher. Mapping goes like this:
+ * - reducer not taking any parameters -> 'empty' dispatcher
+ * - reducer only taking state -> 'empty' dispatcher
+ * - reducer taking state and optional payload (and may also taking optional meta)
+ *    -> dispatcher accepting payload and meta as arguments
+ */
+type ExtractRematchDispatcherFromReducer<TState, TReducer> = TReducer extends (state: TState, ...args: infer TRest) => TState | void ? RematchDispatcher<false, ExtractParametersFromReducer<TRest>> : never;
+/** ************************ Effects Dispatcher ************************* */
+/**
+ * Based on the shape of 'effects' property it extracts dispatchers from it.
+ * 'effects' can be:
+ * - empty - in this case the type is just never
+ * - an object defining effects
+ * - a function returning effects
+ * If it's a function it infers its return type which must define effects.
+ */
+type ExtractRematchDispatchersFromEffects<TEffects extends Model<TModels>['effects'], TModels extends Models<TModels>> = TEffects extends (...args: any[]) => infer R ? R extends ModelEffects<TModels> ? ExtractRematchDispatchersFromEffectsObject<R, TModels> : never : TEffects extends ModelEffects<TModels> ? ExtractRematchDispatchersFromEffectsObject<TEffects, TModels> : never;
+/**
+ * Extracts a dispatcher for each effect that is defined for a model.
+ */
+type ExtractRematchDispatchersFromEffectsObject<TEffects extends ModelEffects<TModels>, TModels extends Models<TModels>> = {
+    [effectKey in keyof TEffects]: ExtractRematchDispatcherFromEffect<TEffects[effectKey], TModels>;
+};
+/**
+ * Utility type used to extract the [payload?, meta?] parameters type
+ * from effect parameters.
+ */
+type ExtractParametersFromEffect<P extends unknown[]> = P extends [] ? [] : P extends [p?: infer TPayload, s?: unknown] ? P extends [infer TPayloadMayUndefined, ...unknown[]] ? [p: TPayloadMayUndefined] : [p?: TPayload] : P extends [
+    p?: infer TPayload,
+    s?: unknown,
+    m?: infer TMeta,
+    ...args: unknown[]
+] ? P extends [
+    infer TPayloadMayUndefined,
+    unknown,
+    infer TMetaMayUndefined,
+    ...unknown[]
+] ? [p: TPayloadMayUndefined, m: TMetaMayUndefined] : P extends [
+    infer TPayloadMayUndefined,
+    unknown?,
+    unknown?,
+    ...unknown[]
+] ? [p: TPayloadMayUndefined, m?: TMeta] : [p?: TPayload, m?: TMeta] : [];
+/**
+ * Extracts a dispatcher for a specific effect that is defined for a model.
+ */
+type ExtractRematchDispatcherFromEffect<TEffect extends ModelEffect<TModels>, TModels extends Models<TModels>> = TEffect extends (...args: infer TRest) => infer TReturn ? RematchDispatcher<true, ExtractParametersFromEffect<TRest>, TReturn> : never;
+/**
+ * `ConvertOptionalToUndefined<T>` is a utility type that transforms the optional properties of type `T`
+ * to explicitly include `undefined` while keeping the required properties unchanged.
+ *
+ * @template T - The original object type with optional and required properties.
+ *
+ * This type works by merging the original type `T` with a new type where:
+ * - The optional properties are identified using a conditional type.
+ * - These optional properties are then transformed to explicitly include `undefined`.
+ * - The required properties remain unchanged.
+ */
+type ConvertOptionalToUndefined<T> = {
+    [K in keyof T | {
+        [k in keyof T]-?: undefined extends T[k] ? k : never;
+    }[keyof T]]: K extends {
+        [k in keyof T]-?: undefined extends T[k] ? k : never;
+    }[keyof T] ? T[K & keyof T] | undefined : K extends keyof T ? T[K] : never;
+};
+interface ModelCreator {
+    <S, RM extends Models<RM>>(): <R extends ModelReducers<S> | undefined, E extends ModelEffects<RM> | ModelEffectsCreator<RM> | undefined, MS extends ModelSelectorsCreator<RM> | undefined>(mo: {
+        name?: string;
+        state: ConvertOptionalToUndefined<S>;
+        reducers?: R;
+        effects?: E;
+        selectors?: MS;
+    }) => {
+        name?: string;
+        state: S;
+    } & (E extends undefined ? object : {
+        effects: E;
+    }) & (R extends undefined ? object : {
+        reducers: R;
+    }) & (MS extends undefined ? object : {
+        selectors: MS;
+    });
+}
+
+declare function createRematchStore<TModels extends Models<TModels>>(initConfig: InitConfig<TModels>): RematchStore<TModels>;
+
+declare const createModel: ModelCreator;
+
+export { type Config, type ConfigRedux, type ExposedFunction, type ExtractRematchDispatcherFromEffect, type ExtractRematchDispatcherFromReducer, type ExtractRematchDispatchersFromEffects, type ExtractRematchDispatchersFromEffectsObject, type ExtractRematchDispatchersFromModels, type ExtractRematchDispatchersFromReducers, type ExtractRematchStateFromModels, type InitConfig, type InitConfigRedux, type Model, type ModelCreator, type ModelDispatcher, type ModelEffect, type ModelEffectThisTyped, type ModelEffects, type ModelEffectsCreator, type ModelReducers, type ModelSelectors, type ModelSelectorsCreator, type Models, type NamedModel, type Reducer, type RematchAction, type RematchDispatch, type RematchDispatcher, type RematchRootState, type RematchStore, createModel, createRematchStore };