import { Action as ReduxAction, Reducer as ReduxReducer, Dispatch as ReduxDispatch, ReducersMapObject, Middleware, StoreEnhancer, StoreCreator, Store as ReduxStore, ActionCreator } from 'redux';
declare type CheckIfParameterOptional
= P extends [unknown, ...unknown[]] ? false : true;
declare type Without = {
[KeyType in Exclude]: never;
};
export declare type MergeExclusive = FirstType | SecondType extends object ? (Without & SecondType) | (Without & FirstType) : FirstType | SecondType;
export interface Action extends ReduxAction {
payload?: TPayload;
meta?: TMeta;
}
export declare type Reducer = (state: TState, payload?: Action['payload'], meta?: Action['meta']) => TState | void;
export interface Models> {
[key: string]: Model;
}
export interface NamedModel, TState = any, TBaseState = TState> extends Model {
name: string;
reducers: ModelReducers;
}
export interface Model, TState = any, TBaseState = TState> {
name?: string;
state: TState;
reducers?: ModelReducers;
baseReducer?: ReduxReducer;
effects?: ModelEffects | ModelEffectsCreator;
}
export declare type ModelReducers = {
[key: string]: Reducer;
};
export interface ModelEffects> {
[key: string]: ModelEffect;
}
export declare type ModelEffectThisTyped = {
[key: string]: (payload?: any, meta?: any) => Action;
};
export declare type ModelEffect> = (this: ModelEffectThisTyped, payload: Action['payload'], rootState: RematchRootState, meta: Action['meta']) => any;
export declare type ModelEffectsCreator> = (dispatch: RematchDispatch) => ModelEffects;
export interface PluginConfig, TExtraModels extends Models, TExposedModels = Partial> {
models?: TExposedModels;
redux?: InitConfigRedux;
}
export interface Plugin, TExtraModels extends Models = Record, TExposedModels = Partial> extends PluginHooks {
config?: PluginConfig;
exposed?: PluginExposed;
}
export interface PluginHooks, TExtraModels extends Models> {
onStoreCreated?: StoreCreatedHook;
onModel?: ModelHook;
onReducer?: ReducerHook;
onRootReducer?: RootReducerHook;
createMiddleware?: MiddlewareCreator;
}
export declare type ModelHook, TExtraModels extends Models> = (model: NamedModel, rematch: RematchStore) => void;
export declare type ReducerHook, TExtraModels extends Models> = (reducer: ReduxReducer, modelName: string, rematch: RematchBag) => ReduxReducer | void;
export declare type RootReducerHook, TExtraModels extends Models> = (reducer: ReduxReducer, rematch: RematchBag) => ReduxReducer | void;
export declare type StoreCreatedHook, TExtraModels extends Models> = (store: RematchStore, rematch: RematchBag) => RematchStore | void;
export declare type MiddlewareCreator, TExtraModels extends Models = Record> = (rematch: RematchBag) => Middleware;
export declare type ObjectNotAFunction = {
[k: string]: any;
} & ({
bind?: never;
} | {
call?: never;
});
export declare type PluginExposed, TExtraModels extends Models> = {
[key: string]: ExposedFunction | ObjectNotAFunction;
};
export declare type ExposedFunction, TExtraModels extends Models> = (rematch: RematchStore, ...args: any) => any;
export interface RematchBag, TExtraModels extends Models> {
models: NamedModel[];
reduxConfig: ConfigRedux;
forEachPlugin: >(method: Hook, fn: (content: NonNullable[Hook]>) => void) => void;
effects: ModelEffects;
}
export interface InitConfig, TExtraModels extends Models> {
name?: string;
models?: TModels | Partial;
plugins?: Plugin[];
redux?: InitConfigRedux;
}
export interface Config, TExtraModels extends Models> extends InitConfig {
name: string;
models: TModels | Partial;
plugins: Plugin[];
redux: ConfigRedux;
}
export interface InitConfigRedux {
initialState?: TRootState;
reducers?: ModelReducers;
enhancers?: StoreEnhancer[];
middlewares?: Middleware[];
rootReducers?: ReducersMapObject;
combineReducers?: ((reducers: ReducersMapObject) => ReduxReducer) | undefined;
createStore?: StoreCreator | undefined;
devtoolOptions?: DevtoolOptions;
devtoolComposer?: DevtoolComposerGeneric;
}
export interface ConfigRedux extends InitConfigRedux {
reducers: ModelReducers;
enhancers: StoreEnhancer[];
middlewares: Middleware[];
rootReducers: ReducersMapObject;
}
export interface RematchStore, TExtraModels extends Models> extends ReduxStore, Action> {
[index: string]: ExposedFunction | Record | string;
name: string;
dispatch: RematchDispatch;
addModel: (model: NamedModel) => void;
}
export declare type RematchRootState, TExtraModels extends Models = Record> = ExtractRematchStateFromModels;
export declare type ExtractRematchStateFromModels, TExtraModels extends Models> = {
[modelKey in keyof TModels]: TModels[modelKey]['state'];
} & {
[modelKey in keyof TExtraModels]: TExtraModels[modelKey]['state'];
};
export declare type RematchDispatch> = ReduxDispatch & ExtractRematchDispatchersFromModels;
export declare type ExtractRematchDispatchersFromModels> = {
[modelKey in keyof TModels]: TModels[modelKey] extends Model ? ModelDispatcher : never;
};
export declare type ModelDispatcher, TModels extends Models> = MergeExclusive, ExtractRematchDispatchersFromReducers>;
export declare type ReturnOfDispatcher = IsEffect extends true ? TReturn : Action;
export declare type RematchDispatcher = [TPayload, TMeta] extends [never, never] ? (() => ReturnOfDispatcher) & {
isEffect: IsEffect;
} : [TMeta] extends [never] ? CheckIfParameterOptional extends true ? ((payload?: TPayload[0]) => ReturnOfDispatcher) & {
isEffect: IsEffect;
} : ((payload: TPayload[0]) => ReturnOfDispatcher) & {
isEffect: IsEffect;
} : CheckIfParameterOptional extends true ? CheckIfParameterOptional extends true ? ((payload?: TPayload[0], meta?: TMeta[0]) => ReturnOfDispatcher) & {
isEffect: IsEffect;
} : ((payload: TPayload[0], meta?: TMeta[0]) => ReturnOfDispatcher) & {
isEffect: IsEffect;
} : ((payload: TPayload[0], meta: TMeta[0]) => ReturnOfDispatcher) & {
isEffect: IsEffect;
};
declare type ExtractParameterFromReducer = P extends [] ? never : P extends [p?: infer TPayload] ? V extends 'payload' ? P extends [infer TPayloadMayUndefined, ...unknown[]] ? [p: TPayloadMayUndefined] : [p?: TPayload] : never : P extends [p?: infer TPayload, m?: infer TMeta, ...args: unknown[]] ? V extends 'payload' ? P extends [infer TPayloadMayUndefined, ...unknown[]] ? [p: TPayloadMayUndefined] : [p?: TPayload] : P extends [unknown, infer TMetaMayUndefined, ...unknown[]] ? [m: TMetaMayUndefined] : [m?: TMeta] : never;
export declare type ExtractRematchDispatchersFromReducers['reducers'], TModels extends Models> = {
[reducerKey in keyof TReducers]: ExtractRematchDispatcherFromReducer;
};
export declare type ExtractRematchDispatcherFromReducer = TReducer extends () => any ? RematchDispatcher : TReducer extends (state: TState, ...args: infer TRest) => TState | void ? TRest extends [] ? RematchDispatcher : TRest[1] extends undefined ? RematchDispatcher> : RematchDispatcher, ExtractParameterFromReducer> : never;
export declare type ExtractRematchDispatchersFromEffects['effects'], TModels extends Models> = TEffects extends (...args: any[]) => infer R ? R extends ModelEffects ? ExtractRematchDispatchersFromEffectsObject : never : TEffects extends ModelEffects ? ExtractRematchDispatchersFromEffectsObject : never;
export declare type ExtractRematchDispatchersFromEffectsObject, TModels extends Models> = {
[effectKey in keyof TEffects]: ExtractRematchDispatcherFromEffect;
};
declare type ExtractParameterFromEffect = P extends [] ? never : P extends [p?: infer TPayload, s?: unknown] ? V extends 'payload' ? P extends [infer TPayloadMayUndefined, ...unknown[]] ? [p: TPayloadMayUndefined] : [p?: TPayload] : never : P extends [
p?: infer TPayload,
s?: unknown,
m?: infer TMeta,
...args: unknown[]
] ? V extends 'payload' ? P extends [infer TPayloadMayUndefined, ...unknown[]] ? [p: TPayloadMayUndefined] : [p?: TPayload] : P extends [unknown, unknown, infer TMetaMayUndefined, ...unknown[]] ? [m: TMetaMayUndefined] : [m?: TMeta] : never;
export declare type ExtractRematchDispatcherFromEffect, TModels extends Models> = TEffect extends (...args: infer TRest) => infer TReturn ? TRest extends [] ? RematchDispatcher : TRest[1] extends undefined ? RematchDispatcher, never, TReturn> : TRest[2] extends undefined ? RematchDispatcher, never, TReturn> : RematchDispatcher, ExtractParameterFromEffect, TReturn> : never;
export interface DevtoolOptions {
disabled?: boolean;
name?: string;
actionCreators?: ActionCreator[] | {
[key: string]: ActionCreator;
};
latency?: number;
maxAge?: number;
serialize?: boolean | {
date?: boolean;
regex?: boolean;
undefined?: boolean;
error?: boolean;
symbol?: boolean;
map?: boolean;
set?: boolean;
function?: boolean | Function;
};
actionSanitizer?: (action: A, id: number) => A;
stateSanitizer?: (state: S, index: number) => S;
actionsBlacklist?: string | string[];
actionsWhitelist?: string | string[];
predicate?: (state: S, action: A) => boolean;
shouldRecordChanges?: boolean;
pauseActionType?: string;
autoPause?: boolean;
shouldStartLocked?: boolean;
shouldHotReload?: boolean;
shouldCatchErrors?: boolean;
features?: {
pause?: boolean;
lock?: boolean;
persist?: boolean;
export?: boolean | 'custom';
import?: boolean | 'custom';
jump?: boolean;
skip?: boolean;
reorder?: boolean;
dispatch?: boolean;
test?: boolean;
};
trace?: boolean | ((action: A) => string);
traceLimit?: number;
[key: string]: any;
}
export interface ModelCreator {
>(): | undefined, BR extends ReduxReducer | undefined, E extends ModelEffects | ModelEffectsCreator | undefined, S, BS = S>(mo: {
name?: string;
state: S;
reducers?: R;
baseReducer?: BR;
effects?: E;
}) => {
name?: string;
state: S;
} & (E extends undefined ? {} : {
effects: E;
}) & (R extends undefined ? {} : {
reducers: R;
}) & (BR extends undefined ? {} : {
baseReducer: BR;
});
}
declare module 'redux' {
interface Dispatch {
[modelName: string]: any;
}
}
declare module 'react-redux' {
interface Connect {
, State, TStateProps, TDispatchProps, TOwnProps>(mapStateToProps: MapStateToPropsParam, mapDispatchToProps: MapRematchDispatchToPropsNonObject): InferableComponentEnhancerWithProps;
}
type MapRematchDispatchToPropsNonObject> = MapRematchDispatchToPropsFactory | MapRematchDispatchToPropsFunction;
type MapRematchDispatchToPropsFactory> = (dispatch: any, ownProps: TOwnProps) => MapRematchDispatchToPropsFunction;
type MapRematchDispatchToPropsFunction> = (dispatch: any, ownProps: TOwnProps) => TDispatchProps;
}
declare global {
interface Window {
__REDUX_DEVTOOLS_EXTENSION_COMPOSE__?: any;
}
}
export {};
//# sourceMappingURL=types.d.ts.map