@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/cjs/middleware/throwNotFoundMiddleware.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates response middleware that throws a `NotFoundError` if the response is undefined.
+ */
+export declare const createThrowNotFoundMiddleware: <Ro>() => () => (response: Promise<Ro> | undefined) => Promise<Ro>;

package/dist/cjs/middleware/throwNotFoundMiddleware.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThrowNotFoundMiddleware = void 0;
+const errors_1 = require("../errors");
+/**
+ * Creates response middleware that throws a `NotFoundError` if the response is undefined.
+ */
+const createThrowNotFoundMiddleware = () => () => (response) => {
+    if (!response) {
+        throw new errors_1.NotFoundError('not found');
+    }
+    return response;
+};
+exports.createThrowNotFoundMiddleware = createThrowNotFoundMiddleware;

package/dist/cjs/misc/hashValue.d.ts

@@ -0,0 +1,10 @@
+export declare type HashValue = string | number | boolean | null | HashCompoundValue;
+export declare type HashCompoundValue = Array<HashValue> | {
+    [key: string]: HashValue;
+};
+/**
+ * creates a string hash of lots of different kinds of things.
+ *
+ * @example hashValue({someKey: 'someValue'})
+ */
+export declare const hashValue: (value: HashValue) => string;

package/dist/cjs/misc/hashValue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashValue = void 0;
+const crypto_1 = require("crypto");
+/**
+ * creates a string hash of lots of different kinds of things.
+ *
+ * @example hashValue({someKey: 'someValue'})
+ */
+const hashValue = (value) => {
+    // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
+    const allKeys = new Set();
+    JSON.stringify(value, (k, v) => (allKeys.add(k), v));
+    const strValue = JSON.stringify(value, Array.from(allKeys).sort());
+    return (0, crypto_1.createHash)('sha1').update(strValue).digest('hex');
+};
+exports.hashValue = hashValue;

package/dist/cjs/misc/helpers.d.ts

@@ -0,0 +1,124 @@
+import type { Logger } from '../services/logger';
+/**
+ * Returns a function that gets the value of the given key from an object
+ *
+ * @param key
+ * @example
+ * const getAuthor = getKeyValue('author');
+ * const author = getAuthor(book);
+ */
+export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
+/**
+ * Returns a function that gets the value of the given key from an object, or the given default
+ * value if the key is not present.
+ *
+ * @param key
+ * @param defaultValue a default value matching the type of the value at the given key
+ * @example
+ * const getAuthorOrNope = getKeyValueOr('author', 'nope');
+ * const authorOrNope = getAuthorOrNope(book);
+ */
+export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K]?: any; } = { [key_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
+/**
+ * Returns a function that sets the value of the given key on an object.
+ *
+ * @param key
+ * @example
+ * const putAuthor = putKeyValue('author');
+ * const newBook = putAuthor(book, 'tom');
+ */
+export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
+/**
+ * Coerces a value into an array. If the value is already an array, it is returned as-is.
+ * If the value is undefined, an empty array is returned.
+ *
+ * @param thing the value
+ * @returns an array
+ */
+export declare const coerceArray: <T>(thing: T | T[] | undefined) => T[];
+declare type FlowFn<A, R> = (...args: [A]) => R;
+declare type AnyFlowFn = FlowFn<any, any>;
+declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
+declare type FlowResult<C, A> = C extends [infer F1, ...infer Cr] ? F1 extends AnyFlowFn ? Cr extends never[] ? FlowFnResult<F1, A> : FlowResult<Cr, FlowFnResult<F1, A>> : never : never;
+declare type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends FlowFn<infer A, any> ? A : never : never;
+/**
+ * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
+ */
+export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
+export declare type RetryOptions = {
+    logger?: Logger;
+    wait?: number;
+    splay?: number;
+    retries?: number;
+    n?: number;
+};
+/**
+ * Retries a function with a delay between retries.
+ * @param fn The function to retry
+ * @param [options] retry options
+ * @param [options.wait=100] base wait of first retry (number), further retries are: t=n*wait,
+ * default: 100
+ * @param [options.splay=0.5] percentage to modify t by. 0.5 is 50%, which would make
+ * t=n*wait+rand(wait*splay*-1, wait*splay), default: 0.5
+ * @param [options.retries=2] number of times to retry. (2 retries means it'll try a max of 3 times),
+ * default: 2
+ * @param [options.n=0] the starting retry index. probably don't set this. unless you really want a very steep
+ *  initial wait cliff with incremental increases, then maybe you'd set this. default: 0
+ * @returns A promise that resolves with the result of the function, or rejects with the last error.
+ */
+export declare const retryWithDelay: <R>(fn: (abort?: ((e: Error) => never) | undefined) => Promise<R>, options?: RetryOptions | undefined) => Promise<R>;
+/**
+ * a shameful helper to avoid needing to test code coverage of branches
+ */
+export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
+/**
+ * maps the array and returns the first result that matches the predicate
+ * avoids processing extra elements that would happen with .map().find() or .reduce
+ *
+ * eg the third element of the array is never processed:
+ *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
+ */
+export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
+/**
+ * returns a function that will only ever call the given function once, returning the first result for every subsequent call
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ *
+ * eg:
+ *   const heavyFunction = () => 'hello';
+ *   const butOnlyOnce = once(() => 'hello');
+ *
+ *   heavyFunction() // returns `hello`;
+ *   butOnlyOnce() // returns `hello`;
+ */
+export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
+/**
+ * memoizes a function with any number of arguments
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ */
+export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
+/**
+ * rounds number to given number of places
+ *
+ * eg:
+ *  roundToPrecision(1234.123, 2); // returns 1200
+ *  roundToPrecision(1234.123, -2); // returns 1234.12
+ *  roundToPrecision(1234.125, -2); // returns 1234.13
+ */
+export declare const roundToPrecision: (num: number, places: number) => number;
+/**
+ * a silly utility to help typescript realize an array is a tuple
+ *
+ * eg:
+ *  const a = [5, 'string'] // type is `Array<string | number>`
+ *  const t = tuple(5, 'string') type is `[5, 'string']`
+ *
+ * both have the same javascript value, but one is forced to be a tuple, which
+ * is nice if its structure is important. examples are like the React.useState
+ * pattern where there are two return values in a tuple, or if you're feeding
+ * Object.fromEntries
+ *
+ */
+export declare const tuple: <A extends any[]>(...args: A) => A;
+export {};

package/dist/cjs/misc/helpers.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tuple = exports.roundToPrecision = exports.memoize = exports.once = exports.mapFind = exports.fnIf = exports.retryWithDelay = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+/*
+ * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
+ * these do more validation that the second function gets a compatible object.
+ */
+/**
+ * Returns a function that gets the value of the given key from an object
+ *
+ * @param key
+ * @example
+ * const getAuthor = getKeyValue('author');
+ * const author = getAuthor(book);
+ */
+const getKeyValue = (key) => (obj) => obj[key];
+exports.getKeyValue = getKeyValue;
+/**
+ * Returns a function that gets the value of the given key from an object, or the given default
+ * value if the key is not present.
+ *
+ * @param key
+ * @param defaultValue a default value matching the type of the value at the given key
+ * @example
+ * const getAuthorOrNope = getKeyValueOr('author', 'nope');
+ * const authorOrNope = getAuthorOrNope(book);
+ */
+const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
+exports.getKeyValueOr = getKeyValueOr;
+/**
+ * Returns a function that sets the value of the given key on an object.
+ *
+ * @param key
+ * @example
+ * const putAuthor = putKeyValue('author');
+ * const newBook = putAuthor(book, 'tom');
+ */
+const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
+exports.putKeyValue = putKeyValue;
+/**
+ * Coerces a value into an array. If the value is already an array, it is returned as-is.
+ * If the value is undefined, an empty array is returned.
+ *
+ * @param thing the value
+ * @returns an array
+ */
+const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
+exports.coerceArray = coerceArray;
+/**
+ * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
+ */
+const flow = (...chain) => (param) => {
+    let result = param;
+    for (const fn of chain) {
+        result = fn(result);
+    }
+    return result;
+};
+exports.flow = flow;
+/**
+ * Retries a function with a delay between retries.
+ * @param fn The function to retry
+ * @param [options] retry options
+ * @param [options.wait=100] base wait of first retry (number), further retries are: t=n*wait,
+ * default: 100
+ * @param [options.splay=0.5] percentage to modify t by. 0.5 is 50%, which would make
+ * t=n*wait+rand(wait*splay*-1, wait*splay), default: 0.5
+ * @param [options.retries=2] number of times to retry. (2 retries means it'll try a max of 3 times),
+ * default: 2
+ * @param [options.n=0] the starting retry index. probably don't set this. unless you really want a very steep
+ *  initial wait cliff with incremental increases, then maybe you'd set this. default: 0
+ * @returns A promise that resolves with the result of the function, or rejects with the last error.
+ */
+const retryWithDelay = (fn, options) => {
+    const { wait, splay, retries, n } = { wait: 100, splay: 0.5, retries: 2, n: 0, ...options };
+    if (n >= retries) {
+        return fn();
+    }
+    let aborted = false;
+    const timeout = (n + 1) * wait + (Math.random() * 2 - 1) * splay * wait;
+    const retry = (e) => new Promise((resolve, reject) => {
+        var _a;
+        if (aborted) {
+            reject(e);
+        }
+        else {
+            (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.log(`failed try ${n + 1} of ${retries}. ${e.message}`);
+            setTimeout(() => (0, exports.retryWithDelay)(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
+        }
+    });
+    const abort = (e) => {
+        aborted = true;
+        throw e;
+    };
+    return fn(abort).catch(retry);
+};
+exports.retryWithDelay = retryWithDelay;
+/**
+ * a shameful helper to avoid needing to test code coverage of branches
+ */
+const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
+exports.fnIf = fnIf;
+/**
+ * maps the array and returns the first result that matches the predicate
+ * avoids processing extra elements that would happen with .map().find() or .reduce
+ *
+ * eg the third element of the array is never processed:
+ *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
+ */
+const mapFind = (array, mapper, predicate = (r) => !!r) => {
+    for (const item of array) {
+        const mapped = mapper(item);
+        if (predicate(mapped)) {
+            return mapped;
+        }
+    }
+};
+exports.mapFind = mapFind;
+/**
+ * returns a function that will only ever call the given function once, returning the first result for every subsequent call
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ *
+ * eg:
+ *   const heavyFunction = () => 'hello';
+ *   const butOnlyOnce = once(() => 'hello');
+ *
+ *   heavyFunction() // returns `hello`;
+ *   butOnlyOnce() // returns `hello`;
+ */
+const once = (fn) => {
+    const initialValue = {};
+    let result = initialValue;
+    return ((...args) => {
+        if (result !== initialValue) {
+            return result;
+        }
+        result = fn(...args);
+        if (typeof result === 'object' && result instanceof Promise) {
+            // Clear the result when possible but do not return a Promise that resolves to the initialValue
+            result.catch(() => result = initialValue);
+        }
+        // If this is a rejected Promise, it should be returned before catch() actually overwrites it
+        return result;
+    });
+};
+exports.once = once;
+/**
+ * memoizes a function with any number of arguments
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ */
+const memoize = (fn) => {
+    const cache = {};
+    const resolveCache = (cacheLayer, [first, ...rest]) => {
+        if (!first) {
+            return cacheLayer;
+        }
+        const layers = first instanceof Object
+            ? (cacheLayer.weakLayers = (cacheLayer.weakLayers || (typeof WeakMap === 'undefined' ? undefined : new WeakMap())))
+            : (cacheLayer.strongLayers = (cacheLayer.strongLayers || new Map()));
+        // argument is an object and WeakMap is not supported
+        if (!layers) {
+            return {};
+        }
+        const layer = layers.get(first) || {};
+        if (!layers.has(first)) {
+            layers.set(first, layer);
+        }
+        return resolveCache(layer, rest);
+    };
+    return ((...args) => {
+        const thisCache = resolveCache(cache, args);
+        if ('result' in thisCache) {
+            return thisCache.result;
+        }
+        thisCache.result = fn(...args);
+        if (typeof thisCache.result === 'object' && thisCache.result instanceof Promise) {
+            // Clear the result when possible but do not return a Promise that resolves to the initialValue
+            thisCache.result.catch(() => delete thisCache.result);
+        }
+        return thisCache.result;
+    });
+};
+exports.memoize = memoize;
+/**
+ * rounds number to given number of places
+ *
+ * eg:
+ *  roundToPrecision(1234.123, 2); // returns 1200
+ *  roundToPrecision(1234.123, -2); // returns 1234.12
+ *  roundToPrecision(1234.125, -2); // returns 1234.13
+ */
+const roundToPrecision = (num, places) => {
+    const multiplier = Math.pow(10, -1 * places);
+    // https://stackoverflow.com/a/11832950/14809536
+    return Math.round((num + Number.EPSILON) * multiplier) / multiplier;
+};
+exports.roundToPrecision = roundToPrecision;
+/**
+ * a silly utility to help typescript realize an array is a tuple
+ *
+ * eg:
+ *  const a = [5, 'string'] // type is `Array<string | number>`
+ *  const t = tuple(5, 'string') type is `[5, 'string']`
+ *
+ * both have the same javascript value, but one is forced to be a tuple, which
+ * is nice if its structure is important. examples are like the React.useState
+ * pattern where there are two return values in a tuple, or if you're feeding
+ * Object.fromEntries
+ *
+ */
+const tuple = (...args) => args;
+exports.tuple = tuple;

package/dist/cjs/misc/merge.d.ts

@@ -0,0 +1,21 @@
+import type { UnionToIntersection } from '../types';
+/**
+ * Takes two objects and returns an array of the keys that are common to both, with a type
+ * limited to those keys.
+ *
+ * @param thing1 some object
+ * @param thing2 another object
+ * @returns an array of keys, type-limited to those keys
+ */
+export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
+/**
+ * recursive merge properties of inputs. values are merged if they are
+ * plain objects or arrays, otherwise if the same property exists in both
+ * objects the value from the second argument will win.
+ *
+ * unlike lodash merge, this will not change object references for values that
+ * exist only in one parameter.
+ *
+ * @example merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ */
+export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

package/dist/cjs/misc/merge.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = exports.getCommonProperties = void 0;
+const guards_1 = require("../guards");
+/**
+ * Takes two objects and returns an array of the keys that are common to both, with a type
+ * limited to those keys.
+ *
+ * @param thing1 some object
+ * @param thing2 another object
+ * @returns an array of keys, type-limited to those keys
+ */
+const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
+exports.getCommonProperties = getCommonProperties;
+/**
+ * recursive merge properties of inputs. values are merged if they are
+ * plain objects or arrays, otherwise if the same property exists in both
+ * objects the value from the second argument will win.
+ *
+ * unlike lodash merge, this will not change object references for values that
+ * exist only in one parameter.
+ *
+ * @example merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ */
+const merge = (...[thing1, ...tail]) => {
+    const mergedTail = tail.length > 0
+        ? (0, exports.merge)(...tail)
+        : null;
+    if (!mergedTail) {
+        return thing1;
+    }
+    return {
+        ...thing1,
+        ...mergedTail,
+        ...(0, exports.getCommonProperties)(thing1, mergedTail).reduce((result, property) => ({
+            ...result,
+            ...((0, guards_1.isPlainObject)(thing1[property]) && (0, guards_1.isPlainObject)(mergedTail[property])
+                ? { [property]: (0, exports.merge)(thing1[property], mergedTail[property]) }
+                : (Array.isArray(thing1[property]) && Array.isArray(mergedTail[property]))
+                    ? { [property]: [...thing1[property], ...mergedTail[property]] }
+                    : {}),
+        }), {}),
+    };
+};
+exports.merge = merge;

package/dist/cjs/misc/partitionSequence.d.ts

@@ -0,0 +1,35 @@
+/**
+ * partitions a sequence based on a partition function returning {value: any; matches?: boolean}
+ *  - if the function returns `matches` explicitly then adjacent matching elements will
+ *    be grouped and the predicate value in the result will be from the last item in the group
+ *  - if the function returns only a value then matching will be evaluated based on the deep
+ *    equality of the value with its neighbors
+ *
+ * this is different from lodash/partition and lodash/groupBy because:
+ *  - it preserves the order of the items, items will only be grouped if they are already adjacent
+ *  - there can be any number of groups
+ *  - it tells you the partition value
+ *  - the partition value can be reduced, if you care (so you can like, partition on sequential values)
+ *
+ *  simple predicate:
+ *    returns: [[0, [1,2]], [1, [3,4,5]]]
+ *    partitionSequence((n: number) => ({value: Math.floor(n / 3)}), [1,2,3,4,5])
+ *
+ *  mutating partition:
+ *    returns: [
+ *      [{min: 1,max: 3}, [1,2,3]],
+ *      [{min: 5,max: 6}, [5,6]],
+ *      [{min: 8,max: 8}, [8]],
+ *    ]
+ *    partitionSequence(
+ *      (n: number, p?: {min: number; max: number}) =>
+ *        p && p.max + 1 === n
+ *          ? {value: {...p, max: n}, matches: true}
+ *          : {value: {min: n, max: n}, matches: false}
+ *      , [1,2,3,5,6,8]
+ *    )
+ */
+export declare const partitionSequence: <T, P>(getPartition: (thing: T, previous?: P | undefined) => {
+    matches?: boolean | undefined;
+    value: P;
+}, sequence: T[]) => [P, T[]][];

package/dist/cjs/misc/partitionSequence.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionSequence = void 0;
+const deep_equal_1 = __importDefault(require("deep-equal"));
+/**
+ * partitions a sequence based on a partition function returning {value: any; matches?: boolean}
+ *  - if the function returns `matches` explicitly then adjacent matching elements will
+ *    be grouped and the predicate value in the result will be from the last item in the group
+ *  - if the function returns only a value then matching will be evaluated based on the deep
+ *    equality of the value with its neighbors
+ *
+ * this is different from lodash/partition and lodash/groupBy because:
+ *  - it preserves the order of the items, items will only be grouped if they are already adjacent
+ *  - there can be any number of groups
+ *  - it tells you the partition value
+ *  - the partition value can be reduced, if you care (so you can like, partition on sequential values)
+ *
+ *  simple predicate:
+ *    returns: [[0, [1,2]], [1, [3,4,5]]]
+ *    partitionSequence((n: number) => ({value: Math.floor(n / 3)}), [1,2,3,4,5])
+ *
+ *  mutating partition:
+ *    returns: [
+ *      [{min: 1,max: 3}, [1,2,3]],
+ *      [{min: 5,max: 6}, [5,6]],
+ *      [{min: 8,max: 8}, [8]],
+ *    ]
+ *    partitionSequence(
+ *      (n: number, p?: {min: number; max: number}) =>
+ *        p && p.max + 1 === n
+ *          ? {value: {...p, max: n}, matches: true}
+ *          : {value: {min: n, max: n}, matches: false}
+ *      , [1,2,3,5,6,8]
+ *    )
+ */
+const partitionSequence = (getPartition, sequence) => {
+    const appendItem = (result, item) => {
+        const current = result[result.length - 1];
+        const itemPartition = getPartition(item, current === null || current === void 0 ? void 0 : current[0]);
+        if (current && ((itemPartition.matches === undefined && (0, deep_equal_1.default)(current[0], itemPartition.value))
+            || itemPartition.matches)) {
+            current[0] = itemPartition.value;
+            current[1].push(item);
+        }
+        else {
+            result.push([itemPartition.value, [item]]);
+        }
+        return result;
+    };
+    return sequence.reduce(appendItem, []);
+};
+exports.partitionSequence = partitionSequence;

package/dist/cjs/pagination/index.d.ts

@@ -0,0 +1,91 @@
+import { QueryParams, RouteMatchRecord } from '../routing';
+export declare type PaginationHandler<Pa, Q extends QueryParams> = <R>(queryParams: Q, match: RouteMatchRecord<R>) => Pa & {
+    getUnusedQueryParams: () => Q;
+};
+/**
+ * helper to create middleware with the given paginator. aside from taking care of annoying to write pagination logic, these helpers also make
+ * sure that all item list responses have the same formatting.
+ *
+ * eg:
+ *   const getQueryParams = getKeyValueOr('queryStringParameters', {} as QueryParams);
+ *   const setUnusedQueryParams = putKeyValue('queryStringParameters');
+ *
+ *   export const loadMorePaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: loadMorePagination});
+ *   export const pageNumberPaginationMiddleware = createPaginationMiddleware<ApiRouteRequest>()({getQueryParams, setUnusedQueryParams, paginator: pageNumberPagination});
+ *
+ * eg the pagination middleware then provides your necessary inputs (getPageToken... in this case) and formats the response:
+ *  const result = await services.myDocumentStore.getVersions(key, services.pagination.getPageTokenNumber());
+ *
+ *  if (!result) {
+ *    throw new NotFoundError('requested item not found');
+ *  }
+ *
+ *  return apiJsonResponse(200, services.pagination.getPaginationResponse(result));
+ */
+export declare const createPaginationMiddleware: <Ri, Q extends QueryParams = {
+    [key: string]: string | undefined;
+}, R = any>() => <Pa>({ getQueryParams, setUnusedQueryParams, paginator }: {
+    getQueryParams: (request: Ri) => Q;
+    setUnusedQueryParams: (request: Ri, query: Q) => Ri;
+    paginator: PaginationHandler<Pa, Q>;
+}) => <M extends {
+    request: Ri;
+}>() => (middleware: M, match: RouteMatchRecord<R>) => M & {
+    pagination: Pa & {
+        getUnusedQueryParams: () => Q;
+    };
+};
+export declare const loadMorePagination: <R, Q extends QueryParams>(queryParams: Q, { route, params }: RouteMatchRecord<R>) => {
+    getUnusedQueryParams: () => Omit<Q, "pageToken">;
+    getPageTokenString: () => string | string[] | null | undefined;
+    getPageTokenNumber: () => number | undefined;
+    getPaginationResponse: <T>({ items, ...meta }: LoadMorePaginationResultInput<T>) => {
+        items: T[];
+        meta: {
+            nextPageToken: string | number | undefined;
+        };
+        links: {
+            nextPage: string | undefined;
+        };
+    };
+};
+/**
+ * if you're writing a data loader, this is what you need to return to be compatible with the loadMore style paginator.
+ * this is how the response formatter knows the token for the next page to put in the response metadata.
+ * */
+export interface LoadMorePaginationResultInput<T> {
+    items: T[];
+    nextPageToken: string | number | undefined;
+}
+export declare const pageNumberPagination: <R, Q extends QueryParams>(queryParams: Q, { route, params }: RouteMatchRecord<R>) => {
+    getUnusedQueryParams: () => Omit<Q, "page">;
+    getPaginationParams: () => {
+        page: number | undefined;
+    };
+    getPaginationResponse: <T>({ items, ...meta }: PageNumberPaginationResultInput<T>) => {
+        items: T[];
+        meta: {
+            pageSize: number;
+            currentPage: number;
+            totalItems: number;
+            totalPages: number;
+        };
+        links: {
+            firstPage: string;
+            lastPage: string;
+            nextPage: string | undefined;
+            prevPage: string | undefined;
+        };
+    };
+};
+/**
+ * if you're writing a data loader, this is what you need to return to be compatible with the pageNumber style paginator.
+ * this is how the response formatter knows the information to put in the response metadata.
+ * */
+export interface PageNumberPaginationResultInput<T> {
+    items: T[];
+    pageSize: number;
+    currentPage: number;
+    totalItems: number;
+    totalPages: number;
+}