@types/recompose

  • Version 0.30.7
  • Published
  • 32.2 kB
  • 1 dependency
  • MIT license

Install

npm i @types/recompose
yarn add @types/recompose
pnpm add @types/recompose

Overview

TypeScript definitions for Recompose

Index

Namespaces

Namespaces

namespace recompose

module 'recompose' {}

    variable onlyUpdateForPropTypes

    const onlyUpdateForPropTypes: InferableComponentEnhancer<{}>;

      variable renderNothing

      const renderNothing: InferableComponentEnhancer<{}>;

        variable toClass

        const toClass: InferableComponentEnhancer<{}>;

          function branch

          branch: <TOutter>(
          test: predicate<TOutter>,
          trueEnhancer: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>,
          falseEnhancer?: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>
          ) => ComponentEnhancer<any, TOutter>;

            function componentFromProp

            componentFromProp: (propName: string) => any;

              function componentFromStream

              componentFromStream: <TProps>(
              propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
              ) => any;

                function componentFromStreamWithConfig

                componentFromStreamWithConfig: (
                config: ObservableConfig
                ) => <TProps>(
                propsToReactNode: mapper<Subscribable<TProps>, Subscribable<any>>
                ) => any;

                  function compose

                  compose: <TInner, TOutter>(
                  ...functions: Function[]
                  ) => ComponentEnhancer<TInner, TOutter>;

                    function createEagerElement

                    createEagerElement: (
                    type: Component<any> | string,
                    props?: Object,
                    children?: any
                    ) => any;

                      function createEagerFactory

                      createEagerFactory: (type: Component<any> | string) => componentFactory;

                        function createEventHandler

                        createEventHandler: <T, TSubs extends Subscribable<T>>() => EventHandlerOf<
                        T,
                        TSubs
                        >;

                          function createEventHandlerWithConfig

                          createEventHandlerWithConfig: (
                          config: ObservableConfig
                          ) => <T, TSubs extends Subscribable<T>>() => EventHandlerOf<T, TSubs>;

                            function createSink

                            createSink: (callback: (props: Object) => void) => any;

                              function defaultProps

                              defaultProps: <T = {}>(props: T) => DefaultingInferableComponentEnhancer<T>;

                                function flattenProp

                                flattenProp: (propName: string) => ComponentEnhancer<any, any>;

                                  function fromRenderProps

                                  fromRenderProps: <TInner, TOutter, TRenderProps = {}>(
                                  RenderPropsComponent: any,
                                  propsMapper: (props: TRenderProps) => TInner,
                                  renderPropName?: string
                                  ) => ComponentEnhancer<TInner & TOutter, TOutter>;

                                    function getContext

                                    getContext: <TContext>(
                                    contextTypes: any
                                    ) => InferableComponentEnhancer<TContext>;

                                      function getDisplayName

                                      getDisplayName: (component: any) => string;

                                        function hoistStatics

                                        hoistStatics: <TProps>(
                                        hoc: InferableComponentEnhancer<TProps>,
                                        blacklist?: { [key: string]: boolean }
                                        ) => InferableComponentEnhancer<TProps>;

                                          function isClassComponent

                                          isClassComponent: (value: any) => boolean;

                                            function lifecycle

                                            lifecycle: <TProps, TState, TInstance = {}>(
                                            spec: ReactLifeCycleFunctions<TProps, TState, TInstance> & TInstance
                                            ) => InferableComponentEnhancer<{}>;

                                              function mapProps

                                              mapProps: <TInner, TOutter>(
                                              propsMapper: mapper<TOutter, TInner>
                                              ) => InferableComponentEnhancerWithProps<TInner, TOutter>;

                                                function mapPropsStream

                                                mapPropsStream: <TInner, TOutter>(
                                                transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
                                                ) => ComponentEnhancer<TInner, TOutter>;

                                                  function mapPropsStreamWithConfig

                                                  mapPropsStreamWithConfig: (
                                                  config: ObservableConfig
                                                  ) => <TInner, TOutter>(
                                                  transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
                                                  ) => ComponentEnhancer<TInner, TOutter>;

                                                    function nest

                                                    nest: (...Components: (string | Component<any>)[]) => any;

                                                      function onlyUpdateForKeys

                                                      onlyUpdateForKeys: {
                                                      (propKeys: Array<string>): InferableComponentEnhancer<{}>;
                                                      <T>(propKeys: (keyof T)[]): InferableComponentEnhancer<{}>;
                                                      };

                                                        function pure

                                                        pure: <TProps>(component: any) => any;

                                                          function renameProp

                                                          renameProp: (
                                                          outterName: string,
                                                          innerName: string
                                                          ) => ComponentEnhancer<any, any>;

                                                            function renameProps

                                                            renameProps: (nameMap: NameMap) => ComponentEnhancer<any, any>;

                                                              function renderComponent

                                                              renderComponent: <TProps>(
                                                              component: string | Component<TProps>
                                                              ) => ComponentEnhancer<any, any>;

                                                                function setDisplayName

                                                                setDisplayName: (displayName: string) => <T extends any>(component: T) => T;

                                                                  function setObservableConfig

                                                                  setObservableConfig: (config: ObservableConfig) => void;

                                                                    function setPropTypes

                                                                    setPropTypes: <P>(propTypes: any) => <T extends any>(component: T) => T;

                                                                      function setStatic

                                                                      setStatic: (key: string, value: any) => <T extends any>(component: T) => T;

                                                                        function shallowEqual

                                                                        shallowEqual: (a: Object, b: Object) => boolean;

                                                                          function shouldUpdate

                                                                          shouldUpdate: <TProps>(
                                                                          test: predicateDiff<TProps>
                                                                          ) => InferableComponentEnhancer<{}>;

                                                                            function toRenderProps

                                                                            toRenderProps: <TInner, TOutter>(
                                                                            hoc: InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>
                                                                            ) => any;

                                                                              function withContext

                                                                              withContext: <TContext, TProps>(
                                                                              childContextTypes: any,
                                                                              getChildContext: mapper<TProps, any>
                                                                              ) => InferableComponentEnhancer<{}>;

                                                                                function withHandlers

                                                                                withHandlers: <TOutter, THandlers>(
                                                                                handlerCreators:
                                                                                | HandleCreators<TOutter, THandlers>
                                                                                | HandleCreatorsFactory<TOutter, THandlers>
                                                                                ) => InferableComponentEnhancerWithProps<THandlers & TOutter, TOutter>;

                                                                                  function withProps

                                                                                  withProps: <TInner, TOutter>(
                                                                                  createProps: TInner | mapper<TOutter, TInner>
                                                                                  ) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

                                                                                    function withPropsOnChange

                                                                                    withPropsOnChange: <TInner, TOutter>(
                                                                                    shouldMapOrKeys: string[] | predicateDiff<TOutter>,
                                                                                    createProps: mapper<TOutter, TInner>
                                                                                    ) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

                                                                                      function withReducer

                                                                                      withReducer: <
                                                                                      TOutter,
                                                                                      TState,
                                                                                      TAction,
                                                                                      TStateName extends string,
                                                                                      TDispatchName extends string
                                                                                      >(
                                                                                      stateName: TStateName,
                                                                                      dispatchName: TDispatchName,
                                                                                      reducer: reducer<TState, TAction>,
                                                                                      initialState: TState | mapper<TOutter, TState>
                                                                                      ) => InferableComponentEnhancerWithProps<
                                                                                      reducerProps<TState, TAction, TStateName, TDispatchName>,
                                                                                      TOutter
                                                                                      >;

                                                                                        function withState

                                                                                        withState: <
                                                                                        TOutter,
                                                                                        TState,
                                                                                        TStateName extends string,
                                                                                        TStateUpdaterName extends string
                                                                                        >(
                                                                                        stateName: TStateName,
                                                                                        stateUpdaterName: TStateUpdaterName,
                                                                                        initialState: TState | mapper<TOutter, TState>
                                                                                        ) => InferableComponentEnhancerWithProps<
                                                                                        stateProps<TState, TStateName, TStateUpdaterName>,
                                                                                        TOutter
                                                                                        >;

                                                                                          function withStateHandlers

                                                                                          withStateHandlers: <
                                                                                          TState,
                                                                                          TUpdaters extends StateHandlerMap<TState>,
                                                                                          TOutter = {}
                                                                                          >(
                                                                                          createProps: TState | mapper<TOutter, TState>,
                                                                                          stateUpdaters: StateUpdaters<TOutter, TState, TUpdaters>
                                                                                          ) => InferableComponentEnhancerWithProps<TOutter & TState & TUpdaters, TOutter>;

                                                                                            function wrapDisplayName

                                                                                            wrapDisplayName: (component: any, wrapperName: string) => string;

                                                                                              interface ComponentEnhancer

                                                                                              interface ComponentEnhancer<TInner, TOutter> {}

                                                                                                call signature

                                                                                                (component: Component<TInner>): ComponentClass<TOutter>;

                                                                                                  interface InferableComponentEnhancerWithProps

                                                                                                  interface InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> {}

                                                                                                    call signature

                                                                                                    <P extends TInjectedProps>(component: Component<P>): React.ComponentClass<
                                                                                                    Omit<P, keyof TInjectedProps> & TNeedsProps
                                                                                                    >;

                                                                                                      interface Observer

                                                                                                      interface Observer<T> {}

                                                                                                        method complete

                                                                                                        complete: () => void;

                                                                                                          method next

                                                                                                          next: (props: T) => void;

                                                                                                            interface ReactLifeCycleFunctions

                                                                                                            interface ReactLifeCycleFunctions<TProps, TState, TInstance = {}> {}

                                                                                                              property componentDidCatch

                                                                                                              componentDidCatch?: (
                                                                                                              this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                              error: Error,
                                                                                                              info: React.ErrorInfo
                                                                                                              ) => void;

                                                                                                                property componentDidMount

                                                                                                                componentDidMount?: (
                                                                                                                this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
                                                                                                                ) => void;

                                                                                                                  property componentDidUpdate

                                                                                                                  componentDidUpdate?: (
                                                                                                                  this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                  prevProps: TProps,
                                                                                                                  prevState: TState
                                                                                                                  ) => void;

                                                                                                                    property componentWillMount

                                                                                                                    componentWillMount?: (
                                                                                                                    this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
                                                                                                                    ) => void;

                                                                                                                      property componentWillReceiveProps

                                                                                                                      componentWillReceiveProps?: (
                                                                                                                      this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                      nextProps: TProps
                                                                                                                      ) => void;

                                                                                                                        property componentWillUnmount

                                                                                                                        componentWillUnmount?: (
                                                                                                                        this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
                                                                                                                        ) => void;

                                                                                                                          property componentWillUpdate

                                                                                                                          componentWillUpdate?: (
                                                                                                                          this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                          nextProps: TProps,
                                                                                                                          nextState: TState
                                                                                                                          ) => void;

                                                                                                                            property shouldComponentUpdate

                                                                                                                            shouldComponentUpdate?: (
                                                                                                                            this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                            nextProps: TProps,
                                                                                                                            nextState: TState
                                                                                                                            ) => boolean;

                                                                                                                              method UNSAFE_componentWillMount

                                                                                                                              UNSAFE_componentWillMount: (
                                                                                                                              this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>
                                                                                                                              ) => void;

                                                                                                                                method UNSAFE_componentWillReceiveProps

                                                                                                                                UNSAFE_componentWillReceiveProps: (
                                                                                                                                this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                                nextProps: TProps
                                                                                                                                ) => void;

                                                                                                                                  method UNSAFE_componentWillUpdate

                                                                                                                                  UNSAFE_componentWillUpdate: (
                                                                                                                                  this: ReactLifeCycleFunctionsThisArguments<TProps, TState, TInstance>,
                                                                                                                                  nextProps: TProps,
                                                                                                                                  nextState: TState
                                                                                                                                  ) => void;

                                                                                                                                    interface Subscribable

                                                                                                                                    interface Subscribable<T> {}

                                                                                                                                      method subscribe

                                                                                                                                      subscribe: (observer: Observer<T>) => Subscription;

                                                                                                                                        interface Subscription

                                                                                                                                        interface Subscription {}

                                                                                                                                          method unsubscribe

                                                                                                                                          unsubscribe: () => void;

                                                                                                                                            type componentFactory

                                                                                                                                            type componentFactory = (
                                                                                                                                            props?: Object,
                                                                                                                                            children?: React.ReactNode
                                                                                                                                            ) => React.ReactElement;

                                                                                                                                              type DefaultingInferableComponentEnhancer

                                                                                                                                              type DefaultingInferableComponentEnhancer<
                                                                                                                                              TInjectedProps
                                                                                                                                              > = InferableComponentEnhancerWithProps<TInjectedProps, Partial<TInjectedProps>>;

                                                                                                                                                type EventHandler

                                                                                                                                                type EventHandler = Function;

                                                                                                                                                  type EventHandlerOf

                                                                                                                                                  type EventHandlerOf<T, TSubs extends Subscribable<T>> = {
                                                                                                                                                  handler: (value: T) => void;
                                                                                                                                                  stream: TSubs;
                                                                                                                                                  };

                                                                                                                                                    type HandleCreators

                                                                                                                                                    type HandleCreators<TOutter, THandlers> = HandleCreatorsStructure<TOutter> &
                                                                                                                                                    HandleCreatorsHandlers<TOutter, THandlers>;

                                                                                                                                                      type HandleCreatorsFactory

                                                                                                                                                      type HandleCreatorsFactory<TOutter, THandlers> = (
                                                                                                                                                      initialProps: TOutter
                                                                                                                                                      ) => HandleCreators<TOutter, THandlers>;

                                                                                                                                                        type HandleCreatorsHandlers

                                                                                                                                                        type HandleCreatorsHandlers<TOutter, THandlers> = {
                                                                                                                                                        [P in keyof THandlers]: (props: TOutter) => THandlers[P];
                                                                                                                                                        };

                                                                                                                                                          type HandleCreatorsStructure

                                                                                                                                                          type HandleCreatorsStructure<TOutter> = {
                                                                                                                                                          [handlerName: string]: mapper<TOutter, EventHandler>;
                                                                                                                                                          };

                                                                                                                                                            type InferableComponentEnhancer

                                                                                                                                                            type InferableComponentEnhancer<
                                                                                                                                                            TInjectedProps
                                                                                                                                                            > = InferableComponentEnhancerWithProps<TInjectedProps, {}>;

                                                                                                                                                              type mapper

                                                                                                                                                              type mapper<TInner, TOutter> = (input: TInner) => TOutter;

                                                                                                                                                                type NameMap

                                                                                                                                                                type NameMap = {
                                                                                                                                                                [outterName: string]: string;
                                                                                                                                                                };

                                                                                                                                                                  type ObservableConfig

                                                                                                                                                                  type ObservableConfig = {
                                                                                                                                                                  fromESObservable?: <T>(observable: Subscribable<T>) => any;
                                                                                                                                                                  toESObservable?: <T>(stream: any) => Subscribable<T>;
                                                                                                                                                                  };

                                                                                                                                                                    type Omit

                                                                                                                                                                    type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

                                                                                                                                                                      type predicate

                                                                                                                                                                      type predicate<T> = mapper<T, boolean>;

                                                                                                                                                                        type predicateDiff

                                                                                                                                                                        type predicateDiff<T> = (current: T, next: T) => boolean;

                                                                                                                                                                          type ReactLifeCycleFunctionsThisArguments

                                                                                                                                                                          type ReactLifeCycleFunctionsThisArguments<
                                                                                                                                                                          TProps,
                                                                                                                                                                          TState,
                                                                                                                                                                          TInstance = {}
                                                                                                                                                                          > = _ReactLifeCycleFunctionsThisArguments<TProps, TState> & TInstance;

                                                                                                                                                                            type reducer

                                                                                                                                                                            type reducer<TState, TAction> = (s: TState, a: TAction) => TState;

                                                                                                                                                                              type reducerProps

                                                                                                                                                                              type reducerProps<
                                                                                                                                                                              TState,
                                                                                                                                                                              TAction,
                                                                                                                                                                              TStateName extends string,
                                                                                                                                                                              TDispatchName extends string
                                                                                                                                                                              > = { [stateName in TStateName]: TState } &
                                                                                                                                                                              { [dispatchName in TDispatchName]: (a: TAction) => void };

                                                                                                                                                                                type StateHandler

                                                                                                                                                                                type StateHandler<TState> = (...payload: any[]) => Partial<TState> | undefined;

                                                                                                                                                                                  type StateHandlerMap

                                                                                                                                                                                  type StateHandlerMap<TState> = {
                                                                                                                                                                                  [updaterName: string]: StateHandler<TState>;
                                                                                                                                                                                  };

                                                                                                                                                                                    type stateProps

                                                                                                                                                                                    type stateProps<
                                                                                                                                                                                    TState,
                                                                                                                                                                                    TStateName extends string,
                                                                                                                                                                                    TStateUpdaterName extends string
                                                                                                                                                                                    > = { [stateName in TStateName]: TState } &
                                                                                                                                                                                    { [stateUpdateName in TStateUpdaterName]: (state: TState) => TState };

                                                                                                                                                                                      type StateUpdaters

                                                                                                                                                                                      type StateUpdaters<TOutter, TState, TUpdaters> = {
                                                                                                                                                                                      [updaterName in keyof TUpdaters]: (
                                                                                                                                                                                      state: TState,
                                                                                                                                                                                      props: TOutter
                                                                                                                                                                                      ) => TUpdaters[updaterName];
                                                                                                                                                                                      };

                                                                                                                                                                                        namespace recompose/baconObservableConfig

                                                                                                                                                                                        module 'recompose/baconObservableConfig' {}

                                                                                                                                                                                          variable baconConfig

                                                                                                                                                                                          const baconConfig: ObservableConfig;

                                                                                                                                                                                            namespace recompose/branch

                                                                                                                                                                                            module 'recompose/branch' {}

                                                                                                                                                                                              function branch

                                                                                                                                                                                              branch: <TOutter>(
                                                                                                                                                                                              test: predicate<TOutter>,
                                                                                                                                                                                              trueEnhancer: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>,
                                                                                                                                                                                              falseEnhancer?: ComponentEnhancer<any, any> | InferableComponentEnhancer<{}>
                                                                                                                                                                                              ) => ComponentEnhancer<any, TOutter>;

                                                                                                                                                                                                namespace recompose/componentFromProp

                                                                                                                                                                                                module 'recompose/componentFromProp' {}

                                                                                                                                                                                                  function componentFromProp

                                                                                                                                                                                                  componentFromProp: (propName: string) => any;

                                                                                                                                                                                                    namespace recompose/componentFromStream

                                                                                                                                                                                                    module 'recompose/componentFromStream' {}

                                                                                                                                                                                                      function componentFromStream

                                                                                                                                                                                                      componentFromStream: <TProps>(
                                                                                                                                                                                                      propsToReactNode: mapper<Subscribable<TProps>, Subscribable<React.ReactNode>>
                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                        function componentFromStreamWithConfig

                                                                                                                                                                                                        componentFromStreamWithConfig: (
                                                                                                                                                                                                        config: ObservableConfig
                                                                                                                                                                                                        ) => <TProps>(
                                                                                                                                                                                                        propsToReactNode: mapper<Subscribable<TProps>, Subscribable<any>>
                                                                                                                                                                                                        ) => any;

                                                                                                                                                                                                          namespace recompose/compose

                                                                                                                                                                                                          module 'recompose/compose' {}

                                                                                                                                                                                                            function compose

                                                                                                                                                                                                            compose: <TInner, TOutter>(
                                                                                                                                                                                                            ...functions: Function[]
                                                                                                                                                                                                            ) => ComponentEnhancer<TInner, TOutter>;

                                                                                                                                                                                                              namespace recompose/createEventHandler

                                                                                                                                                                                                              module 'recompose/createEventHandler' {}

                                                                                                                                                                                                                function createEventHandler

                                                                                                                                                                                                                createEventHandler: <T, TSubs extends Subscribable<T>>() => EventHandlerOf<
                                                                                                                                                                                                                T,
                                                                                                                                                                                                                TSubs
                                                                                                                                                                                                                >;

                                                                                                                                                                                                                  function createEventHandlerWithConfig

                                                                                                                                                                                                                  createEventHandlerWithConfig: (
                                                                                                                                                                                                                  config: ObservableConfig
                                                                                                                                                                                                                  ) => <T, TSubs extends Subscribable<T>>() => EventHandlerOf<T, TSubs>;

                                                                                                                                                                                                                    namespace recompose/createSink

                                                                                                                                                                                                                    module 'recompose/createSink' {}

                                                                                                                                                                                                                      function createSink

                                                                                                                                                                                                                      createSink: (callback: (props: Object) => void) => any;

                                                                                                                                                                                                                        namespace recompose/defaultProps

                                                                                                                                                                                                                        module 'recompose/defaultProps' {}

                                                                                                                                                                                                                          function defaultProps

                                                                                                                                                                                                                          defaultProps: <T = {}>(props: T) => DefaultingInferableComponentEnhancer<T>;

                                                                                                                                                                                                                            namespace recompose/flattenProp

                                                                                                                                                                                                                            module 'recompose/flattenProp' {}

                                                                                                                                                                                                                              function flattenProp

                                                                                                                                                                                                                              flattenProp: (propName: string) => ComponentEnhancer<any, any>;

                                                                                                                                                                                                                                namespace recompose/fromRenderProps

                                                                                                                                                                                                                                module 'recompose/fromRenderProps' {}

                                                                                                                                                                                                                                  function fromRenderProps

                                                                                                                                                                                                                                  fromRenderProps: <TInner, TOutter, TRenderProps = {}>(
                                                                                                                                                                                                                                  RenderPropsComponent: any,
                                                                                                                                                                                                                                  propsMapper: (props: TRenderProps) => TInner,
                                                                                                                                                                                                                                  renderPropName?: string
                                                                                                                                                                                                                                  ) => ComponentEnhancer<TInner & TOutter, TOutter>;

                                                                                                                                                                                                                                    namespace recompose/getContext

                                                                                                                                                                                                                                    module 'recompose/getContext' {}

                                                                                                                                                                                                                                      function getContext

                                                                                                                                                                                                                                      getContext: <TContext>(
                                                                                                                                                                                                                                      contextTypes: any
                                                                                                                                                                                                                                      ) => InferableComponentEnhancer<TContext>;

                                                                                                                                                                                                                                        namespace recompose/getDisplayName

                                                                                                                                                                                                                                        module 'recompose/getDisplayName' {}

                                                                                                                                                                                                                                          function getDisplayName

                                                                                                                                                                                                                                          getDisplayName: (component: any) => string;

                                                                                                                                                                                                                                            namespace recompose/hoistStatics

                                                                                                                                                                                                                                            module 'recompose/hoistStatics' {}

                                                                                                                                                                                                                                              function hoistStatics

                                                                                                                                                                                                                                              hoistStatics: <TProps>(
                                                                                                                                                                                                                                              hoc: InferableComponentEnhancer<TProps>,
                                                                                                                                                                                                                                              blacklist?: { [key: string]: boolean }
                                                                                                                                                                                                                                              ) => InferableComponentEnhancer<TProps>;

                                                                                                                                                                                                                                                namespace recompose/isClassComponent

                                                                                                                                                                                                                                                module 'recompose/isClassComponent' {}

                                                                                                                                                                                                                                                  function isClassComponent

                                                                                                                                                                                                                                                  isClassComponent: (value: any) => boolean;

                                                                                                                                                                                                                                                    namespace recompose/kefirObservableConfig

                                                                                                                                                                                                                                                    module 'recompose/kefirObservableConfig' {}

                                                                                                                                                                                                                                                      variable kefirConfig

                                                                                                                                                                                                                                                      const kefirConfig: ObservableConfig;

                                                                                                                                                                                                                                                        namespace recompose/lifecycle

                                                                                                                                                                                                                                                        module 'recompose/lifecycle' {}

                                                                                                                                                                                                                                                          function lifecycle

                                                                                                                                                                                                                                                          lifecycle: <TProps, TState, TInstance = {}>(
                                                                                                                                                                                                                                                          spec: ReactLifeCycleFunctions<TProps, TState, TInstance> & TInstance
                                                                                                                                                                                                                                                          ) => InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                            namespace recompose/mapProps

                                                                                                                                                                                                                                                            module 'recompose/mapProps' {}

                                                                                                                                                                                                                                                              function mapProps

                                                                                                                                                                                                                                                              mapProps: <TInner, TOutter>(
                                                                                                                                                                                                                                                              propsMapper: mapper<TOutter, TInner>
                                                                                                                                                                                                                                                              ) => InferableComponentEnhancerWithProps<TInner, TOutter>;

                                                                                                                                                                                                                                                                namespace recompose/mapPropsStream

                                                                                                                                                                                                                                                                module 'recompose/mapPropsStream' {}

                                                                                                                                                                                                                                                                  function mapPropsStream

                                                                                                                                                                                                                                                                  mapPropsStream: <TInner, TOutter>(
                                                                                                                                                                                                                                                                  transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
                                                                                                                                                                                                                                                                  ) => ComponentEnhancer<TInner, TOutter>;

                                                                                                                                                                                                                                                                    function mapPropsStreamWithConfig

                                                                                                                                                                                                                                                                    mapPropsStreamWithConfig: (
                                                                                                                                                                                                                                                                    config: ObservableConfig
                                                                                                                                                                                                                                                                    ) => <TInner, TOutter>(
                                                                                                                                                                                                                                                                    transform: mapper<Subscribable<TOutter>, Subscribable<TInner>>
                                                                                                                                                                                                                                                                    ) => ComponentEnhancer<TInner, TOutter>;

                                                                                                                                                                                                                                                                      namespace recompose/mostObservableConfig

                                                                                                                                                                                                                                                                      module 'recompose/mostObservableConfig' {}

                                                                                                                                                                                                                                                                        variable mostConfig

                                                                                                                                                                                                                                                                        const mostConfig: ObservableConfig;

                                                                                                                                                                                                                                                                          namespace recompose/nest

                                                                                                                                                                                                                                                                          module 'recompose/nest' {}

                                                                                                                                                                                                                                                                            function nest

                                                                                                                                                                                                                                                                            nest: (...Components: (string | Component<any>)[]) => any;

                                                                                                                                                                                                                                                                              namespace recompose/onlyUpdateForKeys

                                                                                                                                                                                                                                                                              module 'recompose/onlyUpdateForKeys' {}

                                                                                                                                                                                                                                                                                function onlyUpdateForKeys

                                                                                                                                                                                                                                                                                onlyUpdateForKeys: {
                                                                                                                                                                                                                                                                                (propKeys: Array<string>): InferableComponentEnhancer<{}>;
                                                                                                                                                                                                                                                                                <T>(propKeys: (keyof T)[]): InferableComponentEnhancer<{}>;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  namespace recompose/onlyUpdateForPropTypes

                                                                                                                                                                                                                                                                                  module 'recompose/onlyUpdateForPropTypes' {}

                                                                                                                                                                                                                                                                                    variable onlyUpdateForPropTypes

                                                                                                                                                                                                                                                                                    const onlyUpdateForPropTypes: InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                                                      namespace recompose/pure

                                                                                                                                                                                                                                                                                      module 'recompose/pure' {}

                                                                                                                                                                                                                                                                                        function pure

                                                                                                                                                                                                                                                                                        pure: <TProps>(component: any) => any;

                                                                                                                                                                                                                                                                                          namespace recompose/renameProp

                                                                                                                                                                                                                                                                                          module 'recompose/renameProp' {}

                                                                                                                                                                                                                                                                                            function renameProp

                                                                                                                                                                                                                                                                                            renameProp: (
                                                                                                                                                                                                                                                                                            outterName: string,
                                                                                                                                                                                                                                                                                            innerName: string
                                                                                                                                                                                                                                                                                            ) => ComponentEnhancer<any, any>;

                                                                                                                                                                                                                                                                                              namespace recompose/renameProps

                                                                                                                                                                                                                                                                                              module 'recompose/renameProps' {}

                                                                                                                                                                                                                                                                                                function renameProps

                                                                                                                                                                                                                                                                                                renameProps: (nameMap: NameMap) => ComponentEnhancer<any, any>;

                                                                                                                                                                                                                                                                                                  namespace recompose/renderComponent

                                                                                                                                                                                                                                                                                                  module 'recompose/renderComponent' {}

                                                                                                                                                                                                                                                                                                    function renderComponent

                                                                                                                                                                                                                                                                                                    renderComponent: <TProps>(
                                                                                                                                                                                                                                                                                                    component: string | Component<TProps>
                                                                                                                                                                                                                                                                                                    ) => ComponentEnhancer<any, any>;

                                                                                                                                                                                                                                                                                                      namespace recompose/renderNothing

                                                                                                                                                                                                                                                                                                      module 'recompose/renderNothing' {}

                                                                                                                                                                                                                                                                                                        variable renderNothing

                                                                                                                                                                                                                                                                                                        const renderNothing: InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                                                                          namespace recompose/rxjs4ObservableConfig

                                                                                                                                                                                                                                                                                                          module 'recompose/rxjs4ObservableConfig' {}

                                                                                                                                                                                                                                                                                                            variable rxjs4config

                                                                                                                                                                                                                                                                                                            const rxjs4config: ObservableConfig;

                                                                                                                                                                                                                                                                                                              namespace recompose/rxjsObservableConfig

                                                                                                                                                                                                                                                                                                              module 'recompose/rxjsObservableConfig' {}

                                                                                                                                                                                                                                                                                                                variable rxjsconfig

                                                                                                                                                                                                                                                                                                                const rxjsconfig: ObservableConfig;

                                                                                                                                                                                                                                                                                                                  namespace recompose/setDisplayName

                                                                                                                                                                                                                                                                                                                  module 'recompose/setDisplayName' {}

                                                                                                                                                                                                                                                                                                                    function setDisplayName

                                                                                                                                                                                                                                                                                                                    setDisplayName: (displayName: string) => <T extends any>(component: T) => T;

                                                                                                                                                                                                                                                                                                                      namespace recompose/setObservableConfig

                                                                                                                                                                                                                                                                                                                      module 'recompose/setObservableConfig' {}

                                                                                                                                                                                                                                                                                                                        function setObservableConfig

                                                                                                                                                                                                                                                                                                                        setObservableConfig: (config: ObservableConfig) => void;

                                                                                                                                                                                                                                                                                                                          namespace recompose/setPropTypes

                                                                                                                                                                                                                                                                                                                          module 'recompose/setPropTypes' {}

                                                                                                                                                                                                                                                                                                                            function setPropTypes

                                                                                                                                                                                                                                                                                                                            setPropTypes: <P>(propTypes: any) => <T extends any>(component: T) => T;

                                                                                                                                                                                                                                                                                                                              namespace recompose/setStatic

                                                                                                                                                                                                                                                                                                                              module 'recompose/setStatic' {}

                                                                                                                                                                                                                                                                                                                                function setStatic

                                                                                                                                                                                                                                                                                                                                setStatic: (key: string, value: any) => <T extends any>(component: T) => T;

                                                                                                                                                                                                                                                                                                                                  namespace recompose/shallowEqual

                                                                                                                                                                                                                                                                                                                                  module 'recompose/shallowEqual' {}

                                                                                                                                                                                                                                                                                                                                    function shallowEqual

                                                                                                                                                                                                                                                                                                                                    shallowEqual: (a: Object, b: Object) => boolean;

                                                                                                                                                                                                                                                                                                                                      namespace recompose/shouldUpdate

                                                                                                                                                                                                                                                                                                                                      module 'recompose/shouldUpdate' {}

                                                                                                                                                                                                                                                                                                                                        function shouldUpdate

                                                                                                                                                                                                                                                                                                                                        shouldUpdate: <TProps>(
                                                                                                                                                                                                                                                                                                                                        test: predicateDiff<TProps>
                                                                                                                                                                                                                                                                                                                                        ) => InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                                                                                                          namespace recompose/toClass

                                                                                                                                                                                                                                                                                                                                          module 'recompose/toClass' {}

                                                                                                                                                                                                                                                                                                                                            variable toClass

                                                                                                                                                                                                                                                                                                                                            const toClass: InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                                                                                                              namespace recompose/toRenderProps

                                                                                                                                                                                                                                                                                                                                              module 'recompose/toRenderProps' {}

                                                                                                                                                                                                                                                                                                                                                function toRenderProps

                                                                                                                                                                                                                                                                                                                                                toRenderProps: <TInner, TOutter>(
                                                                                                                                                                                                                                                                                                                                                hoc: InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>
                                                                                                                                                                                                                                                                                                                                                ) => any;

                                                                                                                                                                                                                                                                                                                                                  namespace recompose/withContext

                                                                                                                                                                                                                                                                                                                                                  module 'recompose/withContext' {}

                                                                                                                                                                                                                                                                                                                                                    function withContext

                                                                                                                                                                                                                                                                                                                                                    withContext: <TContext, TProps>(
                                                                                                                                                                                                                                                                                                                                                    childContextTypes: any,
                                                                                                                                                                                                                                                                                                                                                    getChildContext: mapper<TProps, any>
                                                                                                                                                                                                                                                                                                                                                    ) => InferableComponentEnhancer<{}>;

                                                                                                                                                                                                                                                                                                                                                      namespace recompose/withHandlers

                                                                                                                                                                                                                                                                                                                                                      module 'recompose/withHandlers' {}

                                                                                                                                                                                                                                                                                                                                                        function withHandlers

                                                                                                                                                                                                                                                                                                                                                        withHandlers: <TOutter, THandlers>(
                                                                                                                                                                                                                                                                                                                                                        handlerCreators:
                                                                                                                                                                                                                                                                                                                                                        | HandleCreators<TOutter, THandlers>
                                                                                                                                                                                                                                                                                                                                                        | HandleCreatorsFactory<TOutter, THandlers>
                                                                                                                                                                                                                                                                                                                                                        ) => InferableComponentEnhancerWithProps<THandlers & TOutter, TOutter>;

                                                                                                                                                                                                                                                                                                                                                          namespace recompose/withProps

                                                                                                                                                                                                                                                                                                                                                          module 'recompose/withProps' {}

                                                                                                                                                                                                                                                                                                                                                            function withProps

                                                                                                                                                                                                                                                                                                                                                            withProps: <TInner, TOutter>(
                                                                                                                                                                                                                                                                                                                                                            createProps: TInner | mapper<TOutter, TInner>
                                                                                                                                                                                                                                                                                                                                                            ) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

                                                                                                                                                                                                                                                                                                                                                              namespace recompose/withPropsOnChange

                                                                                                                                                                                                                                                                                                                                                              module 'recompose/withPropsOnChange' {}

                                                                                                                                                                                                                                                                                                                                                                function withPropsOnChange

                                                                                                                                                                                                                                                                                                                                                                withPropsOnChange: <TInner, TOutter>(
                                                                                                                                                                                                                                                                                                                                                                shouldMapOrKeys: string[] | predicateDiff<TOutter>,
                                                                                                                                                                                                                                                                                                                                                                createProps: mapper<TOutter, TInner>
                                                                                                                                                                                                                                                                                                                                                                ) => InferableComponentEnhancerWithProps<TInner & TOutter, TOutter>;

                                                                                                                                                                                                                                                                                                                                                                  namespace recompose/withReducer

                                                                                                                                                                                                                                                                                                                                                                  module 'recompose/withReducer' {}

                                                                                                                                                                                                                                                                                                                                                                    function withReducer

                                                                                                                                                                                                                                                                                                                                                                    withReducer: <
                                                                                                                                                                                                                                                                                                                                                                    TOutter,
                                                                                                                                                                                                                                                                                                                                                                    TState,
                                                                                                                                                                                                                                                                                                                                                                    TAction,
                                                                                                                                                                                                                                                                                                                                                                    TStateName extends string,
                                                                                                                                                                                                                                                                                                                                                                    TDispatchName extends string
                                                                                                                                                                                                                                                                                                                                                                    >(
                                                                                                                                                                                                                                                                                                                                                                    stateName: TStateName,
                                                                                                                                                                                                                                                                                                                                                                    dispatchName: TDispatchName,
                                                                                                                                                                                                                                                                                                                                                                    reducer: reducer<TState, TAction>,
                                                                                                                                                                                                                                                                                                                                                                    initialState: TState | mapper<TOutter, TState>
                                                                                                                                                                                                                                                                                                                                                                    ) => InferableComponentEnhancerWithProps<
                                                                                                                                                                                                                                                                                                                                                                    reducerProps<TState, TAction, TStateName, TDispatchName>,
                                                                                                                                                                                                                                                                                                                                                                    TOutter
                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                      namespace recompose/withState

                                                                                                                                                                                                                                                                                                                                                                      module 'recompose/withState' {}

                                                                                                                                                                                                                                                                                                                                                                        function withState

                                                                                                                                                                                                                                                                                                                                                                        withState: <
                                                                                                                                                                                                                                                                                                                                                                        TOutter,
                                                                                                                                                                                                                                                                                                                                                                        TState,
                                                                                                                                                                                                                                                                                                                                                                        TStateName extends string,
                                                                                                                                                                                                                                                                                                                                                                        TStateUpdaterName extends string
                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                        stateName: TStateName,
                                                                                                                                                                                                                                                                                                                                                                        stateUpdaterName: TStateUpdaterName,
                                                                                                                                                                                                                                                                                                                                                                        initialState: TState | mapper<TOutter, TState>
                                                                                                                                                                                                                                                                                                                                                                        ) => InferableComponentEnhancerWithProps<
                                                                                                                                                                                                                                                                                                                                                                        stateProps<TState, TStateName, TStateUpdaterName>,
                                                                                                                                                                                                                                                                                                                                                                        TOutter
                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                          namespace recompose/withStateHandlers

                                                                                                                                                                                                                                                                                                                                                                          module 'recompose/withStateHandlers' {}

                                                                                                                                                                                                                                                                                                                                                                            function withStateHandlers

                                                                                                                                                                                                                                                                                                                                                                            withStateHandlers: <
                                                                                                                                                                                                                                                                                                                                                                            TState,
                                                                                                                                                                                                                                                                                                                                                                            TUpdaters extends StateHandlerMap<TState>,
                                                                                                                                                                                                                                                                                                                                                                            TOutter = {}
                                                                                                                                                                                                                                                                                                                                                                            >(
                                                                                                                                                                                                                                                                                                                                                                            createProps: TState | mapper<TOutter, TState>,
                                                                                                                                                                                                                                                                                                                                                                            stateUpdaters: StateUpdaters<TOutter, TState, TUpdaters>
                                                                                                                                                                                                                                                                                                                                                                            ) => InferableComponentEnhancerWithProps<TOutter & TState & TUpdaters, TOutter>;

                                                                                                                                                                                                                                                                                                                                                                              namespace recompose/wrapDisplayName

                                                                                                                                                                                                                                                                                                                                                                              module 'recompose/wrapDisplayName' {}

                                                                                                                                                                                                                                                                                                                                                                                function wrapDisplayName

                                                                                                                                                                                                                                                                                                                                                                                wrapDisplayName: (component: any, wrapperName: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                  namespace recompose/xstreamObservableConfig

                                                                                                                                                                                                                                                                                                                                                                                  module 'recompose/xstreamObservableConfig' {}

                                                                                                                                                                                                                                                                                                                                                                                    variable xstreamConfig

                                                                                                                                                                                                                                                                                                                                                                                    const xstreamConfig: ObservableConfig;

                                                                                                                                                                                                                                                                                                                                                                                      Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/recompose.

                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/recompose)
                                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@types/recompose"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>