@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -1,21 +0,0 @@
-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) => Array<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 Array<{}>>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

package/dist/esm/misc/merge.js

@@ -1,40 +0,0 @@
-import { isPlainObject } from '../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
- */
-export const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
-/**
- * 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 const merge = (...[thing1, ...tail]) => {
-    const mergedTail = tail.length > 0
-        ? merge(...tail)
-        : null;
-    if (!mergedTail) {
-        return thing1;
-    }
-    return {
-        ...thing1,
-        ...mergedTail,
-        ...getCommonProperties(thing1, mergedTail).reduce((result, property) => ({
-            ...result,
-            ...(isPlainObject(thing1[property]) && isPlainObject(mergedTail[property])
-                ? { [property]: merge(thing1[property], mergedTail[property]) }
-                : (Array.isArray(thing1[property]) && Array.isArray(mergedTail[property]))
-                    ? { [property]: [...thing1[property], ...mergedTail[property]] }
-                    : {}),
-        }), {}),
-    };
-};

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

@@ -1,35 +0,0 @@
-/**
- * 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) => {
-    matches?: boolean;
-    value: P;
-}, sequence: T[]) => [P, T[]][];

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

@@ -1,91 +0,0 @@
-import { QueryParams, RouteMatchRecord } from '../routing';
-export 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;
-}

package/dist/esm/pagination/index.js

@@ -1,77 +0,0 @@
-import { notNaN } from '../assertions';
-import { InvalidRequestError } from '../errors';
-import { renderAnyRouteUrl } from '../routing';
-/**
- * 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 const createPaginationMiddleware = () => ({ getQueryParams, setUnusedQueryParams, paginator }) => () => (middleware, match) => {
-    const queryParams = getQueryParams(middleware.request);
-    const pagination = paginator(queryParams, match);
-    // remove pagination params from downstream logic
-    middleware.request = setUnusedQueryParams(middleware.request, pagination.getUnusedQueryParams());
-    return { ...middleware, pagination };
-};
-export const loadMorePagination = (queryParams, { route, params }) => {
-    const { pageToken, ...otherParams } = queryParams;
-    return {
-        getUnusedQueryParams: () => otherParams,
-        getPageTokenString: () => pageToken,
-        getPageTokenNumber: () => pageToken && typeof pageToken === 'string'
-            ? notNaN(parseInt(pageToken, 10), () => { throw new InvalidRequestError(); })
-            : undefined,
-        getPaginationResponse: ({ items, ...meta }) => {
-            return {
-                items,
-                meta,
-                links: {
-                    nextPage: meta.nextPageToken
-                        ? renderAnyRouteUrl(route, params, { ...queryParams, pageToken: meta.nextPageToken.toString() })
-                        : undefined,
-                }
-            };
-        },
-    };
-};
-export const pageNumberPagination = (queryParams, { route, params }) => {
-    const { page, ...otherParams } = queryParams;
-    const numberPage = page && typeof page === 'string'
-        ? notNaN(parseInt(page, 10), () => { throw new InvalidRequestError(); })
-        : undefined;
-    return {
-        getUnusedQueryParams: () => otherParams,
-        getPaginationParams: () => ({ page: numberPage }),
-        getPaginationResponse: ({ items, ...meta }) => {
-            return {
-                items,
-                meta,
-                links: {
-                    firstPage: renderAnyRouteUrl(route, params, { ...queryParams, page: '1' }),
-                    lastPage: renderAnyRouteUrl(route, params, { ...queryParams, page: meta.totalPages.toString() }),
-                    nextPage: meta.currentPage < meta.totalPages
-                        ? renderAnyRouteUrl(route, params, { ...queryParams, page: (meta.currentPage + 1).toString() })
-                        : undefined,
-                    prevPage: meta.currentPage > 1
-                        ? renderAnyRouteUrl(route, params, { ...queryParams, page: (meta.currentPage - 1).toString() })
-                        : undefined
-                }
-            };
-        },
-    };
-};

package/dist/esm/routing/helpers.d.ts

@@ -1,57 +0,0 @@
-import type { HttpHeaders } from '.';
-/**
- * Get the value of a header, case insensitive; note if there are multiple headers of the same
- * value, this only returns the first value
- *
- * @param headers
- * @param name the name of the header, case ignored
- */
-export declare const getHeader: (headers: HttpHeaders, name: string) => string | undefined;
-/**
- * Gets the body of a request
- * @param request
- * @throws InvalidRequestError if the content type is not application/json or not parsable
- */
-export declare const getRequestBody: (request: {
-    headers: HttpHeaders;
-    body?: string | undefined;
-}) => any;
-/**
- * stub validator because writing validators is annoying
- */
-export declare const unsafePayloadValidator: <T>() => (input: any) => input is T;
-/**
- * Middleware that validates the request payload and adds it to the middleware (with key `payload`)
- * so it can be accessed downstream.
- *
- * This middleware accomplishes a few things:
- *   - establishes type of payload for route body logic
- *   - validates the payload for route logic
- *   - establishes type of payload for client logic calling this route
- *
- * @param validator a guard function that takes the request payload and returns true if it is valid,
- * narrowing the type of the payload to the correct type
- * @throws InvalidRequestError if the payload is not valid
- *
- * @example
- * export const exampleRoute = createRoute({
- *   name: 'exampleRoute', method: METHOD.POST, path: '/example/:id',
- *   requestServiceProvider: composeServiceMiddleware(
- *     // here we are adding to previously composed middleware
- *     requestServiceProvider,
- *     requestPayloadProvider(validatePayload)
- *   )},
- *   async(params: {id: string}, services) => {
- *     const result = await services.myDocumentStore.putItem({
- *       ...services.payload,
- *       id: params.id,
- *     });
- *     return apiJsonResponse(201, result);
- *   }
- * );
- */
-export declare const requestPayloadProvider: <T>(validator: (input: any) => input is T) => () => <M extends {
-    request: Parameters<typeof getRequestBody>[0];
-}>(requestServices: M) => M & {
-    payload: T;
-};

package/dist/esm/routing/index.d.ts

@@ -1,290 +0,0 @@
-import { Logger } from '../services/logger';
-/** HTTP query parameters */
-export type QueryParams = Record<string, string | undefined | string[] | null>;
-/**
- * The type for a map of string substitutions to use when building route paths, e.g. a route may
- * be defined as `'/api/:id'` and then rendered as `'/api/123'` when the `id` route param is set
- * to `'123'`
- */
-export type RouteParams = {
-    [key: string]: string;
-};
-/** A type that is compatible with any `Route` type */
-export type AnyRoute<R> = R extends Route<infer N, infer P, infer Sa, infer Sr, infer Ri, infer Ro> ? Route<N, P, Sa, Sr, Ri, Ro> : never;
-export type AnySpecificRoute<R, Sa, Ri, Ro> = R extends Route<infer N, infer P, Sa, infer Sr, Ri, Ro> & infer E ? Route<N, P, Sa, Sr, Ri, Ro> & E : never;
-/** The inferred "route output" (`Ro`) type for a given route */
-export type OutputForRoute<R> = R extends Route<any, any, any, any, any, infer Ro> ? Ro : never;
-/** The inferred type for the params of the provided route type, `R`; may be undefined */
-export type ParamsForRoute<R> = R extends Route<any, infer P, any, any, any, any> ? P : never;
-/** The inferred type for the request services of the provided route type, `R`. */
-export type RequestServicesForRoute<R> = R extends Route<any, any, any, infer Sr, any, any> ? Sr : never;
-/** The type for the params of the provided route type, `R`; will be `{}` if undefined */
-export type ParamsForRouteOrEmpty<R> = ParamsForRoute<R> extends undefined ? {} : Exclude<ParamsForRoute<R>, undefined>;
-/** derives the route match type for this route, which includes the route itself and the matching params. */
-export type RouteMatchRecord<R> = R extends AnyRoute<R> ? {
-    route: R;
-    params: ParamsForRoute<R>;
-} : never;
-type Flatten<T> = T extends any ? {
-    [K in keyof T]: T[K];
-} : never;
-export type ExternalRoute<R> = R extends Route<infer N, infer P, infer Sa, infer Sr, infer Ri, infer Ro> & infer E ? Route<N, P, Sa, Sr extends {
-    payload: any;
-} ? Flatten<Pick<Sr, 'payload'>> : Record<string, never>, Ri, Ro> & Flatten<Omit<E, 'name' | 'path' | 'handler' | 'requestServiceProvider'>> : never;
-/** this utility simplifies the route type to remove stuff that is only
- * relevant internal to the route, like the service types, keeping only
- * the payload type which is necessary for the apiGateway
- *
- * this helps avoid the "type too complicated" error that typescript throws
- * when there are a lot of routes with complex services
- **/
-export declare const routesList: <R>(routes: R[]) => ExternalRoute<R>[];
-/**
- * The conditional type for the payload for a given route, `R`. This isn't a route structure, its
- * a convention based on the request middleware
- */
-export type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
-    payload: any;
-} ? RequestServicesForRoute<R>['payload'] : undefined;
-type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
-    request: Ri;
-    logger: Logger;
-}, match: RouteMatchRecord<R>) => Sr;
-type RouteHandler<P, Sr, Ro> = (params: P, request: Sr) => Ro;
-type Route<N extends string, P extends RouteParams | undefined, Sa, Sr, Ri, Ro> = (Sr extends undefined ? {
-    requestServiceProvider?: RequestServiceProvider<Sa, Sr, Ri> | undefined;
-} : {
-    requestServiceProvider: RequestServiceProvider<Sa, Sr, Ri>;
-}) & {
-    name: N;
-    path: string;
-    handler: (params: P, request: Sr) => Ro;
-};
-type CreateRouteConfig<Sa, Sr, Ri, N extends string, Ex> = (Sr extends undefined ? {
-    requestServiceProvider?: RequestServiceProvider<Sa, Sr, Ri> | undefined;
-} : {
-    requestServiceProvider: RequestServiceProvider<Sa, Sr, Ri>;
-}) & {
-    name: N;
-    path: string;
-} & Ex;
-/**
- * Interface for a function that creates a route. There are two overloaded signatures, because
- * sometimes typescript can't figure out the value of `Sr` between the handler and the service
- * provider. Forcing it through the provider types first by putting the handler in a subsequent
- * argument seems to help.
- */
-export interface CreateRoute<Sa, Ri, Ex> {
-    <N extends string, Ro, Sr extends unknown | undefined = undefined, P extends RouteParams | undefined = undefined>(config: CreateRouteConfig<Sa, Sr, Ri, N, Ex> & {
-        handler: RouteHandler<P, Sr, Ro>;
-    }): Route<N, P, Sa, Sr, Ri, Ro> & Ex;
-    <N extends string, Ro, Sr extends unknown | undefined, P extends RouteParams | undefined = undefined>(config: CreateRouteConfig<Sa, Sr, Ri, N, Ex>, handler: RouteHandler<P, Sr, Ro>): Route<N, P, Sa, Sr, Ri, Ro> & Ex;
-}
-/**
- * Makes a createRoute function that can be used to create routes (this is a factory factory). The
- * `makeCreateRoute` function is typically called once in the backend and once in the frontend to
- * set the types for the resulting `createRoute` function -- that latter function is called once
- * per route. E.g. for the backend, the call could look like:
- *
- * ```
- * export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
- *   method: METHOD;
- * }>();
- * ```
- *
- * Notes:
- * * The `{method: METHOD}` defines the `Ex` extension type; here, the `method` property is only
- *   relevant to backend routes.
- * * when defining the `createRoute` method, only the request input format is defined, the output
- *   format is derived from the routes.
- *
- * When calling the resulting `createRoute` function, the only required params of the route are the
- * name, path, and handler. Other params can be added to the type and then later used in the
- * routeMatcher.
- *
- * eg when defining requestServiceProvider in line, the types have a hard time, it helps to put in another argument:
- * ```
- * export const exampleRoute = createRoute({
- *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
- *   requestServiceProvider: composeServiceMiddleware({
- *     cookieAuthMiddleware,
- *     documentStoreMiddleware,
- *   }},
- *   async(params: {key: string}, services) => {
- *     const result = await services.myDocumentStore.getItem(params.key);
- *
- *     if (!result) {
- *       throw new NotFoundError('requested item not found');
- *     }
- *
- *     return apiJsonResponse(200, result);
- *   }
- * );
- * ```
- * eg when using a pre-existing provider variable the types work better:
- * ```
- * export const exampleRoute = createRoute({
- *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
- *   requestServiceProvider,
- *   handler: async(params: {key: string}, services) => {
- *     const result = await services.myDocumentStore.getItem(params.key);
- *
- *     if (!result) {
- *       throw new NotFoundError('requested item not found');
- *     }
- *
- *     return apiJsonResponse(200, result);
- *   }
- * });
- * ```
- */
-export declare const makeCreateRoute: <Sa, Ri, Ex = {}>() => CreateRoute<Sa, Ri, Ex>;
-/**
- * Makes a renderRouteUrl function that can be used to render route paths (this is a factory
- * factory). The returned function takes a `route`, `params`, and `query` and returns a string
- * with the params and query substituted into the route path.
- *
- * this function is initialized using the Ru type which indicates the specific routes wired into
- * the application, which means that if you try to build a url with a route which is not wired
- * into the router you will get a type error. this is a feature to prevent referencing routes that
- * don't exist or aren't handling requests properly.
- *
- * if you are making a helper function or need to render a route outside your application, you
- * can use the `renderAnyRouteUrl` function
- */
-export declare const makeRenderRouteUrl: <Ru extends {
-    path: string;
-}>() => <R>(route: ExternalRoute<R> extends Ru ? R & {
-    path: string;
-} : R extends Ru ? R : never, params: ParamsForRoute<R>, query?: QueryParams) => string;
-/**
- * A pre-made result from `makeRenderRouteUrl`, this function interpolates parameter and query
- * arguments into a route path.
- *
- * prefer using `renderRouteUrl` initialized with your applications route union
- * when possible to help catch improperly initialized routes.
- *
- * @param route the route that has a `path` to be interpolated
- * @param params the parameters to interpolate into the route path
- * @param query the query parameters to add to the route path
- * @returns the interpolated route path
- */
-export declare const renderAnyRouteUrl: <R>(route: ExternalRoute<R> extends any ? R & {
-    path: string;
-} : R extends any ? R : never, params: ParamsForRoute<R>, query?: QueryParams) => string;
-type RequestPathExtractor<Ri> = (request: Ri) => string;
-type RequestLogExtractor<Ri> = (request: Ri) => JsonCompatibleStruct;
-type RequestRouteMatcher<Ri, R> = (request: Ri, route: R) => boolean;
-type CompatibleServices<T1> = keyof T1 extends 'logger' ? T1 extends {
-    logger: Logger;
-} ? T1 : never : T1 & {
-    logger?: Logger;
-};
-type RequestResponder<Sa, Ri, Ro> = {
-    (services: CompatibleServices<Sa>): (request: Ri) => Ro | undefined;
-    <RoF>(services: CompatibleServices<Sa>, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: {
-        request: Ri;
-        logger: Logger;
-    }) => RoF): (request: Ri) => RoF;
-};
-/**
- * A factory factory for creating request responders (functions that take a request and return a
- * response -- these functions let us implement Lambda `handler` functions).
- *
- * Use it in two steps. First, call it with the general business logic that defines routes, logs,
- * errors, etc:
- * ```
- * const getRequestResponder = makeGetRequestResponder<
- *    AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>
- *   >()  // this empty invocation helps typescript mix defined and inferred types
- *   ({
- *     routes: apiRoutes, // the route definitions
- *     pathExtractor,     // how to get the path out of the request format
- *     routeMatcher,      // logic for matching route (beyond path matching, optional)
- *     errorHandler,      // any special error handling
- *   });
- * ```
- * Note here that among other things we're specifying a generic response format that the response
- * and error handling middleware can use, if any routes have responses that don't adhere to this
- * it'll complain about it.
- *
- * Next, we use the `getRequestResponder` to create a responder for a specific lambda entrypoint:
- * ```
- * export const handler: (request: APIGatewayProxyEventV2): Promise<ApiRouteResponse> =>
- *   getRequestResponder(
- *     lambdaServices,  // the AppServices for this entrypoint
- *     lambdaMiddleware // environment specific response middleware (like cors)
- *   );
- * ```
- */
-export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }: {
-    routes: () => AnySpecificRoute<Ru, Sa, Ri, Ro>[];
-    pathExtractor: RequestPathExtractor<Ri>;
-    logExtractor?: RequestLogExtractor<Ri>;
-    routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>>;
-    errorHandler?: (e: Error, logger: Logger) => Ro;
-}) => RequestResponder<Sa, Ri, Ro>;
-/** HTTP Headers */
-export type HttpHeaders = {
-    [key: string]: string | undefined | string[];
-};
-/** A type that works in JSON */
-export type JsonCompatibleValue = string | number | null | undefined | boolean;
-/** A JSON array type */
-export type JsonCompatibleArray = Array<JsonCompatibleValue | JsonCompatibleStruct | JsonCompatibleStruct>;
-/** A JSON object type */
-export type JsonCompatibleStruct = {
-    [key: string]: JsonCompatibleStruct | JsonCompatibleValue | JsonCompatibleArray;
-};
-/** The type for an API response */
-export type ApiResponse<S extends number, T> = {
-    isBase64Encoded?: boolean;
-    statusCode: S;
-    data: T;
-    body: string;
-    headers?: {
-        [key: string]: string;
-    };
-};
-/**
- * Returns a JSON response. Handles serializing the data to JSON and setting the content-type header.
- * @param statusCode e.g. 201
- * @param data the object to be serialized to JSON
- * @param headers HTTP headers
- * @example
- * return apiJsonResponse(
- *   200, {
- *     message: "hello, world!",
- *     foo: "bar",
- *   },
- *   { 'X-Frame-Options': 'DENY' }
- * );
- */
-export declare const apiJsonResponse: <S extends number, T extends JsonCompatibleStruct>(statusCode: S, data: T, headers?: HttpHeaders) => ApiResponse<S, T>;
-/**
- * Returns a plain text response. Handles setting the content-type header.
- * @param statusCode e.g. 201
- * @param data some string
- * @param headers HTTP headers
- * @example return apiTextResponse(200, 'some text')
- */
-export declare const apiTextResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders) => ApiResponse<S, string>;
-/**
- * Returns an HTML response. Handles setting the content-type header.
- * @param statusCode e.g. 201
- * @param data some string
- * @param headers HTTP headers
- * @example return apiHtmlResponse(200, '<b>some text</b>')
- */
-export declare const apiHtmlResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders) => ApiResponse<S, string>;
-/** HTTP method enum */
-export declare enum METHOD {
-    GET = "GET",
-    HEAD = "HEAD",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    DELETE = "DELETE",
-    OPTIONS = "OPTIONS"
-}
-export * from './helpers';