function factory(
    showModal: (s: State) => boolean,
    closeActionEmitter: () => Action,
    applyActionEmitter: () => Action
) {

    function mapStateToProps(state: State): PendingChangesModalComponent.Props {
        return {
            show: showModal(state)
        };
    }

    return connect(
        mapStateToProps,
        {
            onHide: () => closeActionEmitter(),
            onContinueAndDiscard: () => batch(
                applyActionEmitter(),
                closeActionEmitter()
            ),
            onContinueAndSave: () => batch(
                saveCurrentCartride(),
                applyActionEmitter(),
                closeActionEmitter()
            )
        }
    )(PendingChangesModalComponent);
}

export default <TInner extends {}, TOutter extends {}>(
  mapEventsToProps: (ownProps: TOutter, eventsData: Linode.Event[]) => TInner,
) => connect((state: ApplicationState, ownProps: TOutter) => {
  const eventsData = state.events.events;

  return mapEventsToProps(ownProps, eventsData);
});

) => <TUIState, TMappedProps = Props<TUIState>>(
  id: string,
  mapProps?: MapCreateUIStateProps<TUIState, TMappedProps>,
) => connect(
  (state: TAppState, props: UIStateComponentProps<TMappedProps>) => ({
    uiState: uiStateSelector(
      state, Object.assign({ uiStateId: id, uiStateBranchSelector }, props)
    ) as TUIState,
  }),
  (dispatch) => ({
    setUIState: setUIStateSelector<TUIState, UIStateIdProps<{}>>(dispatch, { uiStateId: id }),
  }),
  // Using Object.assign here to avoid "Spread types may only be created from object types"
  // https://github.com/Microsoft/TypeScript/issues/10727
  (stateProps, dispatchProps, ownProps) => Object.assign(
    {},
    ownProps,
    mapProps
      ? mapProps({...stateProps, ...dispatchProps})
      : {...stateProps, ...dispatchProps}
  )
)((props) => {
  // Until TypeScript allows spread on interfaces, force props to any to allow ES7 rest syntax
  // https://github.com/Microsoft/TypeScript/issues/16780
  // tslint:disable-next-line:no-any
  const { children, ...rest } = props as any;
  return children(rest);
});

export default <TInner extends {}, TOutter extends {}>(
  mapAccountToProps: (ownProps: TOutter, account?: Linode.Profile) => TInner
) =>
  connect((state: ApplicationState, ownProps: TOutter) => {
    const profile = state.__resources.profile.data;

    return mapAccountToProps(ownProps, profile);
  });

export default <TInner extends {}, TOutter extends {}>(
  mapToProps: MapProps<TOutter, TInner>
) =>
  connect((state: ApplicationState, ownProps: TOutter) => {
    const { loading, error, entities } = state.__resources.linodes;

    return mapToProps(ownProps, entities, loading, error);
  });

export const withNotifications = (
  mapState: (s: State) => any = defaultMapState,
  mapDispatch: (actions: Actions) => any = defaultMapDispatch
) =>
  connect(
    (state: ApplicationState) => mapState(state.__resources.notifications),
    mapDispatch(actions)
  );

export default <TInner extends {}, TOutter extends {}>(
  mapImagesToProps: (ownProps: TOutter, images: Linode.Image[], imagesLoading: boolean, imageError?: string ) => TInner,
) => connect((state: ApplicationState, ownProps: TOutter) => {
  const images = state.__resources.images.entities;
  const imagesLoading = state.__resources.images.loading;
  const { error } = state.__resources.images;
  const imageError = isEmpty(error) ? error![0].reason : undefined; // @todo use updated error handling utils after they're merged

  return mapImagesToProps(ownProps, images, imagesLoading, imageError);
});

export default <AppState, Data>({
    namespace,
    contentTypes,
}: {
    namespace: string
    contentTypes: Array<IContentType<Data>>
}) => {
    const actions = actionsFactory<Data>(namespace)

    const mapStateToProps = ({
        panes
    }: AppState & {
        panes: IPanesState<Data>
    }) => {
        const entry = panes[namespace]

        return {
            namespace,
            root: entry === undefined ? undefined : entry.panes.find(pane => pane.childOf === undefined),
            panes: entry === undefined ? [] : entry.panes,
            contentTypes
        }
    }

    const mapDispatchToProps = (dispatch: Dispatch) => ({
        init:  () => {
            dispatch(actions.initPanesNamespace())
        },
        setCurrentPane: (paneId: string) => {
            dispatch(actions.setCurrentPane(paneId))
        },
        addContentToCurrentPane: (content: IPaneContent<Data>) => {
            dispatch(actions.addContentToCurrentPane(content))
        },
        setPaneCurrentContent: (paneId: string, contentId: string) => {
            dispatch(actions.setPaneCurrentContent(paneId, contentId))
        },
        removePaneContent: (paneId: string, contentId: string) => {
            dispatch(actions.removePaneContent(paneId, contentId))
        },
        removeContentFromAllPanes: (contentId: string) => {
            dispatch(actions.removeContentFromAllPanes(contentId))
        },
        splitPane: (paneId: string, axis: PaneSplitAxis) => {
            dispatch(actions.splitPane(paneId, axis))
        },
    })

    class NameSpacedPaneManager extends PaneManager<Data> {}

    return connect(
        mapStateToProps,
        mapDispatchToProps
    )(NameSpacedPaneManager)
}

export default <TInner extends {}, TOutter extends {}>(
  mapVolumesToProps: (ownProps: TOutter, volumesData: VolumesData, volumesLoading: boolean, volumesError?: Error ) => TInner,
) => connect((state: ApplicationState, ownProps: TOutter) => {
  const { items, itemsById } = state.__resources.volumes;

  const volumesData = { items, itemsById };
  const volumesLoading = state.__resources.volumes.loading;
  const volumesError = state.__resources.volumes.error;

  return mapVolumesToProps(ownProps, volumesData, volumesLoading, volumesError);
});

}: Config = {}) => (
    mapStateToProps,
    mapActionsToProps?: any
  ) => {
  const makeMapStateToProps = () => mapSelectors(selectors, mapStateToProps)

  let connectState = connect(makeMapStateToProps)

  if (mapActionsToProps) {
    const mapDispatchToProps = (dispatch: Dispatch<State>, ownProps: OP) => (
      mapActions(actions, mapActionsToProps, { dispatch, ownProps })
    )

    connectState = connect(makeMapStateToProps, mapDispatchToProps)
  }

  return compose(
   connectState,
   stateHOC
  )
}