/**
     * Sends all subscribed values to the Reactotron app.
     *
     * @param node The tree to grab the state data from
     */
    function sendSubscriptions(state: any) {
      // this is unreadable
      const changes = pipe(
        map(when(isNil, always(""))) as any,
        filter(endsWith(".*")),
        map((key: string) => {
          const keyMinusWildcard = slice(0, -2, key)
          const value = dotPath(keyMinusWildcard, state)
          if (is(Object, value) && !isNilOrEmpty(value)) {
            return pipe(keys, map(key => `${keyMinusWildcard}.${key}`))(value)
          }
          return []
        }) as any,
        concat(map(when(isNil, always("")), subscriptions)),
        flatten,
        reject(endsWith(".*")) as any,
        uniq as any,
        sortBy(identity) as any,
        map((key: string) => ({
          path: key,
          value: isNilOrEmpty(key) ? state : dotPath(key, state),
        })),
      )(subscriptions)

      reactotron.stateValuesChange(changes)
    }

export default curry((defaultValue: number, v?: null | string | number) =>
  compose<
    string | number | null | undefined,
    number | null | undefined,
    number>(
      defaultTo(defaultValue),
      when(compose(not, isEmpty), (value: string) => +value),
  )(v));

 fs.readdirSync(root).map((name: string) =>
     compose(
         getOrElse(null),
         when(isDirectory, filePath =>
             getPrefixedRoutesFromMap(getPrefixedRoute)(
                 requireFilePath(filePath, 'index.js'),
                 requireFilePath(filePath, 'config.json')
             )
         )
     )(resolve(root, name))

    return async (ctx, next) => {
        R.when(isTruthy, () => {
            const roles = R.pathOr([], ['state', 'accessRoles'], ctx) as string[];
            const hasAccess = roles.some(accessMap(ctx));

            if (roles.length && !hasAccess) ctx.throw(401, 'Unauthorised access to endpoint');
        })(accessMap);

        await next();
    };

export const setHeaders = (headers: any = {}) =>
  when(() => isNotEmpty(headers), set(L.headers, headers));

		const apply = (m, s) => R.when(isModuloOf(m), R.always(s))