@openstax/ts-utils 1.29.0 → 1.30.1

package/dist/cjs/types.d.ts

@@ -6,26 +6,26 @@
  *
  * There may be a better way to do this; `T1 extends T2` doesn't work
  */
-export declare type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
+export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
 /**
  * unions each member of the tuple
  */
-export declare type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
+export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
 /**
  * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
  * @deprecated use TypeScript builtin Awaited instead:
  * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements
  */
-export declare type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
+export type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
 /**
  * turns `thing | thing2` into `thing & thing2`
  * @see https://stackoverflow.com/a/50375286/14809536
  */
-export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
  * make certain fields required
  * @see https://stackoverflow.com/a/69328045/14809536
  */
-export declare type WithRequired<T, K extends keyof T> = T & {
+export type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };

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

@@ -1,4 +1,4 @@
-export declare type AssertionFailed = string | Error | (() => never) | undefined;
+export type AssertionFailed = string | Error | (() => never) | undefined;
 export declare const doThrow: (failed: AssertionFailed) => never;
 /**
  * Asserts that the given value is true.
@@ -70,7 +70,9 @@ export declare const notNaN: <T>(thing: T, failed?: AssertionFailed) => T;
  * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
  * @returns the value that was asserted
  */
-export declare const assertInstanceOf: <T>(thing: any, constructable: Function & (new (...args: any[]) => T), failed?: AssertionFailed) => T;
+export declare const assertInstanceOf: <T>(thing: any, constructable: Function & {
+    new (...args: any[]): T;
+}, failed?: AssertionFailed) => T;
 /**
  * Asserts that the error in the first argument is an instance of the error given as the
  * second argument
@@ -82,4 +84,6 @@ export declare const assertInstanceOf: <T>(thing: any, constructable: Function &
  * @throws the original error if the check fails
  * @see assertInstanceOf
  */
-export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & (new (...args: any[]) => T)) => T;
+export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & {
+    new (...args: any[]): T;
+}) => T;

package/dist/esm/config/envConfig.d.ts

@@ -21,4 +21,4 @@ export declare const ENV_BUILD_CONFIGS: string[];
  *
  * @example const config = { configValue: envConfig('environment_variable_name') };
  */
-export declare const envConfig: (name: string, type?: "build" | "runtime" | undefined, defaultValue?: ConfigValueProvider<string> | undefined) => ConfigValueProvider<string>;
+export declare const envConfig: (name: string, type?: "build" | "runtime", defaultValue?: ConfigValueProvider<string>) => ConfigValueProvider<string>;

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

@@ -1,29 +1,29 @@
 /**
  * A simple type alias for a string that represents a configuration value. Currently only string values are supported to maintain compatibility with environment variables, but this type is future proofing against allowing other types like `number` as possible config values.
  */
-export declare type ConfigValue = string;
+export type ConfigValue = string;
 /**
  * A configuration object that may contain nested configuration objects or configuration values.
  */
-export declare type Config = {
+export type Config = {
     [key: string]: Config | ConfigValue;
 };
 /**
  * Either a function that returns a `ConfigValue` or a `Promise` that resolves to a `ConfigValue`,
  * or just a `ConfigValue`.
  */
-export declare type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
+export type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
 /**
  * A configuration object that may contain nested configuration objects or configuration value providers.
  */
-export declare type ConfigProvider = {
+export type ConfigProvider = {
     [key: string]: ConfigProvider | ConfigValueProvider;
 };
 /**
  * Conditional type that resolves to the type of configuration object for the given configuration
  * provider. Also resolves to a config value type if the given type is a config value.
  */
-export declare type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T extends ConfigProvider ? {
+export type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T extends ConfigProvider ? {
     [key in keyof T]: ConfigForConfigProvider<T[key]>;
 } : T extends ConfigValueProvider<infer R> ? R : never;
 /**
@@ -31,7 +31,7 @@ export declare type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T e
  * type (`ConfigValue` or `Config`). The resulting type is either a `ConfigValueProvider` or
  * a `ConfigProvider`.
  */
-export declare type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
+export type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
     [key in keyof T]: ConfigProviderForConfig<T[key]>;
 } : never;
 export * from './resolveConfigValue';
@@ -41,7 +41,7 @@ export * from './resolveConfigValue';
  *
  * @example const config = { configValue: stubConfig('just-a-string') };
  */
-export declare const stubConfig: <V extends string>(configValue: V) => ConfigValueProvider<V>;
+export declare const stubConfig: <V extends ConfigValue>(configValue: V) => ConfigValueProvider<V>;
 export * from './envConfig';
 export * from './replaceConfig';
 export * from './awsParameterConfig';

package/dist/esm/config/resolveConfigValue.d.ts

@@ -1,5 +1,5 @@
-import type { ConfigValueProvider } from '.';
+import type { ConfigValue, ConfigValueProvider } from '.';
 /**
  * resolves a config value into a string, to be used inside of things that are provided configurations
  */
-export declare const resolveConfigValue: <V extends string>(provider: ConfigValueProvider<V>) => Promise<V>;
+export declare const resolveConfigValue: <V extends ConfigValue>(provider: ConfigValueProvider<V>) => Promise<V>;

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

@@ -5,44 +5,44 @@ export declare enum FetchStateType {
     LOADING = "loading",
     IDLE = "idle"
 }
-export declare type FetchState<D, E> = FetchStateLoading<D> | FetchStateError<D, E> | FetchStateSuccess<D> | FetchStateIdle;
-declare type FetchStateLoading<D> = {
+export type FetchState<D, E> = FetchStateLoading<D> | FetchStateError<D, E> | FetchStateSuccess<D> | FetchStateIdle;
+type FetchStateLoading<D> = {
     type: FetchStateType.LOADING;
     data?: D;
 };
-declare type FetchStateError<D, E> = {
+type FetchStateError<D, E> = {
     type: FetchStateType.ERROR;
     data?: D;
     error: E;
 };
-declare type FetchStateSuccess<D> = {
+type FetchStateSuccess<D> = {
     type: FetchStateType.SUCCESS;
     data: D;
 };
-declare type FetchStateIdle = {
+type FetchStateIdle = {
     type: FetchStateType.IDLE;
 };
-export declare const fetchLoading: <D, E>(previous?: FetchState<D, E> | undefined) => FetchStateLoading<D>;
-export declare const fetchError: <D, E>(error: E, previous?: FetchState<D, E> | undefined) => FetchStateError<D, E>;
+export declare const fetchLoading: <D, E>(previous?: FetchState<D, E>) => FetchStateLoading<D>;
+export declare const fetchError: <D, E>(error: E, previous?: FetchState<D, E>) => FetchStateError<D, E>;
 export declare const fetchSuccess: <D>(data: D) => FetchStateSuccess<D>;
 export declare const fetchIdle: () => FetchStateIdle;
 export declare const stateHasData: <D, E>(state: {
     type: FetchStateType;
-    data?: D | undefined;
-    error?: E | undefined;
+    data?: D;
+    error?: E;
 }) => state is {
     type: FetchStateType;
     data: D;
 };
 export declare const stateHasError: <D, E>(state: {
     type: FetchStateType;
-    data?: D | undefined;
-    error?: E | undefined;
+    data?: D;
+    error?: E;
 }) => state is {
     type: FetchStateType;
     error: E;
 };
-export declare type FetchConfig = {
+export type FetchConfig = {
     credentials?: 'include' | 'omit' | 'same-origin';
     method?: METHOD;
     body?: string;
@@ -50,15 +50,15 @@ export declare type FetchConfig = {
         [key: string]: string;
     };
 };
-declare type Headers = {
+type Headers = {
     get: (name: string) => string | null;
 };
-export declare type Response = {
+export type Response = {
     status: number;
     headers: Headers;
     json: () => Promise<any>;
     text: () => Promise<string>;
 };
-export declare type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> = (url: string, fetchConfig?: C) => Promise<R>;
-export declare type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;
+export type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> = (url: string, fetchConfig?: C) => Promise<R>;
+export type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;
 export {};

package/dist/esm/middleware/apiErrorHandler.d.ts

@@ -1,7 +1,7 @@
 import { ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
 import type { ApiResponse } from '../routing';
 import type { Logger } from '../services/logger';
-export declare type DefaultErrors = {
+export type DefaultErrors = {
     InvalidRequestError: InvalidRequestError;
     UnauthorizedError: UnauthorizedError;
     ForbiddenError: ForbiddenError;
@@ -9,7 +9,7 @@ export declare type DefaultErrors = {
     ValidationError: ValidationError;
     SessionExpiredError: SessionExpiredError;
 };
-export declare type Handlers<E> = {
+export type Handlers<E> = {
     [T in keyof E]?: (e: E[T], logger: Logger) => ApiResponse<number, any>;
 };
 export declare const defaultHandlers: Handlers<DefaultErrors>;
@@ -21,4 +21,4 @@ export declare const defaultHandlers: Handlers<DefaultErrors>;
  *
  * @param inputHandlers a map of errors to handler functions
  */
-export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors> | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;
+export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors>) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;

package/dist/esm/middleware/apiSlowResponseMiddleware.d.ts

@@ -1,7 +1,7 @@
 import type { ConfigProviderForConfig } from '../config';
 import type { ApiResponse } from '../routing';
 import type { Logger } from '../services/logger';
-declare type Config = {
+type Config = {
     logResponseSlowerThan: string;
     timeoutResponseAfter: string;
 };

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

@@ -1,11 +1,11 @@
 import { TupleZip } from '../types';
-export declare type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa, appBinder?: ((app: Sa, provider: MiddlewareProvider<Sa, M, A, R>) => (middleware: M, ...args: A) => R)) => (middleware: M, ...args: A) => R;
-export declare type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
-export declare type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
-export declare type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? (Omit<R, keyof M> & M) extends R ? Omit<R, keyof M> & M : R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;
-export declare type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
-export declare type ServiceMiddlewareProviderChainResult<C, M> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderResult<M, S1> : ServiceMiddlewareProviderChainResult<S, ServiceMiddlewareProviderResult<M, S1>> : C extends unknown ? M : never;
-export declare type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleZip<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> : C extends unknown ? [] : never;
+export type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa, appBinder?: ((app: Sa, provider: MiddlewareProvider<Sa, M, A, R>) => (middleware: M, ...args: A) => R)) => (middleware: M, ...args: A) => R;
+export type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
+export type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
+export type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? (Omit<R, keyof M> & M) extends R ? Omit<R, keyof M> & M : R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;
+export type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
+export type ServiceMiddlewareProviderChainResult<C, M> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderResult<M, S1> : ServiceMiddlewareProviderChainResult<S, ServiceMiddlewareProviderResult<M, S1>> : C extends unknown ? M : never;
+export type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleZip<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> : C extends unknown ? [] : never;
 /**
  * Creates a middleware composer for given AppServices and input value types. The composer accepts a list of middleware
  * that it assembles into a chain. The function returned by the composer takes a value of the given input value type,

package/dist/esm/middleware/lambdaCorsResponseMiddleware.d.ts

@@ -1,7 +1,7 @@
 import { APIGatewayProxyEventV2 } from 'aws-lambda';
 import { ConfigProviderForConfig } from '../config';
 import { ApiResponse } from '../routing';
-declare type Config = {
+type Config = {
     corsAllowedHostRegex: string;
 };
 /**

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

@@ -1,5 +1,5 @@
-export declare type HashValue = string | number | boolean | null | HashCompoundValue;
-export declare type HashCompoundValue = Array<HashValue> | {
+export type HashValue = string | number | boolean | null | HashCompoundValue;
+export type HashCompoundValue = Array<HashValue> | {
     [key: string]: HashValue;
 };
 /**

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

@@ -7,7 +7,7 @@ import type { Logger } from '../services/logger';
  * 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];
+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.
@@ -18,7 +18,7 @@ export declare const getKeyValue: <K extends string>(key: K) => <O extends { [ke
  * 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]>;
+export declare const getKeyValueOr: <K extends string, V, Od extends { [_key in K]?: any; } = { [_key in K]?: any; }>(key: K, defaultValue: V) => <O extends (Od extends undefined ? { [_key in K]?: any; } : Od)>(obj: O) => NonNullable<O[K]> | V;
 /**
  * Returns a function that sets the value of the given key on an object.
  *
@@ -27,7 +27,7 @@ export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K
  * 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;
+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.
@@ -35,17 +35,17 @@ export declare const putKeyValue: <K extends string>(key: K) => <O extends { [ke
  * @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;
+export declare const coerceArray: <T>(thing: undefined | T | T[]) => T[];
+type FlowFn<A, R> = (...args: [A]) => R;
+type AnyFlowFn = FlowFn<any, any>;
+type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
+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;
+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 = {
+export type RetryOptions = {
     logger?: Logger;
     wait?: number;
     splay?: number;
@@ -66,7 +66,7 @@ export declare type RetryOptions = {
  *  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>;
+export declare const retryWithDelay: <R>(fn: (abort?: (e: Error) => never) => Promise<R>, options?: RetryOptions) => Promise<R>;
 /**
  * a shameful helper to avoid needing to test code coverage of branches
  */

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

@@ -7,7 +7,7 @@ import type { UnionToIntersection } from '../types';
  * @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)[];
+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
@@ -18,4 +18,4 @@ export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1:
  *
  * @example merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
  */
-export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;
+export declare const merge: <T extends Array<{}>>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

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

@@ -29,7 +29,7 @@
  *      , [1,2,3,5,6,8]
  *    )
  */
-export declare const partitionSequence: <T, P>(getPartition: (thing: T, previous?: P | undefined) => {
-    matches?: boolean | undefined;
+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,5 +1,5 @@
 import { QueryParams, RouteMatchRecord } from '../routing';
-export declare type PaginationHandler<Pa, Q extends QueryParams> = <R>(queryParams: Q, match: RouteMatchRecord<R>) => Pa & {
+export type PaginationHandler<Pa, Q extends QueryParams> = <R>(queryParams: Q, match: RouteMatchRecord<R>) => Pa & {
     getUnusedQueryParams: () => Q;
 };
 /**

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

@@ -1,27 +1,27 @@
 import { Logger } from '../services/logger';
 /** HTTP query parameters */
-export declare type QueryParams = Record<string, string | undefined | string[] | null>;
+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 declare type RouteParams = {
+export type RouteParams = {
     [key: string]: string;
 };
 /** A type that is compatible with any `Route` type */
-export declare 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 declare 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;
+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 declare type OutputForRoute<R> = R extends Route<any, any, any, any, any, infer Ro> ? Ro : never;
+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 declare type ParamsForRoute<R> = R extends Route<any, infer P, any, any, any, any> ? P : never;
+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 declare type RequestServicesForRoute<R> = R extends Route<any, any, any, infer Sr, any, any> ? Sr : never;
+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 declare type ParamsForRouteOrEmpty<R> = ParamsForRoute<R> extends undefined ? {} : Exclude<ParamsForRoute<R>, 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 declare type RouteMatchRecord<R> = R extends AnyRoute<R> ? {
+export type RouteMatchRecord<R> = R extends AnyRoute<R> ? {
     route: R;
     params: ParamsForRoute<R>;
 } : never;
@@ -29,15 +29,15 @@ export declare type RouteMatchRecord<R> = R extends AnyRoute<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 declare type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
+export type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
     payload: any;
 } ? RequestServicesForRoute<R>['payload'] : undefined;
-declare type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
+type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
     request: Ri;
     logger: Logger;
 }, match: RouteMatchRecord<R>) => Sr;
-declare type RouteHandler<P, Sr, Ro> = (params: P, request: Sr) => Ro;
-declare type Route<N extends string, P extends RouteParams | undefined, Sa, Sr, Ri, Ro> = (Sr extends undefined ? {
+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>;
@@ -46,7 +46,7 @@ declare type Route<N extends string, P extends RouteParams | undefined, Sa, Sr,
     path: string;
     handler: (params: P, request: Sr) => Ro;
 };
-declare type CreateRouteConfig<Sa, Sr, Ri, N extends string, Ex> = (Sr extends undefined ? {
+type CreateRouteConfig<Sa, Sr, Ri, N extends string, Ex> = (Sr extends undefined ? {
     requestServiceProvider?: RequestServiceProvider<Sa, Sr, Ri> | undefined;
 } : {
     requestServiceProvider: RequestServiceProvider<Sa, Sr, Ri>;
@@ -154,15 +154,15 @@ export declare const makeRenderRouteUrl: <Ru extends {
  * @returns the interpolated route path
  */
 export declare const renderAnyRouteUrl: <R extends any>(route: R, params: ParamsForRoute<R>, query?: QueryParams) => string;
-declare type RequestPathExtractor<Ri> = (request: Ri) => string;
-declare type RequestLogExtractor<Ri> = (request: Ri) => JsonCompatibleStruct;
-declare type RequestRouteMatcher<Ri, R> = (request: Ri, route: R) => boolean;
-declare type CompatibleServices<T1> = keyof T1 extends 'logger' ? T1 extends {
+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;
 };
-declare type RequestResponder<Sa, Ri, Ro> = {
+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;
@@ -202,24 +202,24 @@ declare type RequestResponder<Sa, Ri, Ro> = {
 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> | undefined;
-    routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>> | undefined;
-    errorHandler?: ((e: Error, logger: Logger) => Ro) | undefined;
+    logExtractor?: RequestLogExtractor<Ri>;
+    routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>>;
+    errorHandler?: (e: Error, logger: Logger) => Ro;
 }) => RequestResponder<Sa, Ri, Ro>;
 /** HTTP Headers */
-export declare type HttpHeaders = {
+export type HttpHeaders = {
     [key: string]: string | undefined | string[];
 };
 /** A type that works in JSON */
-export declare type JsonCompatibleValue = string | number | null | undefined | boolean;
+export type JsonCompatibleValue = string | number | null | undefined | boolean;
 /** A JSON array type */
-export declare type JsonCompatibleArray = Array<JsonCompatibleValue | JsonCompatibleStruct | JsonCompatibleStruct>;
+export type JsonCompatibleArray = Array<JsonCompatibleValue | JsonCompatibleStruct | JsonCompatibleStruct>;
 /** A JSON object type */
-export declare type JsonCompatibleStruct = {
+export type JsonCompatibleStruct = {
     [key: string]: JsonCompatibleStruct | JsonCompatibleValue | JsonCompatibleArray;
 };
 /** The type for an API response */
-export declare type ApiResponse<S extends number, T> = {
+export type ApiResponse<S extends number, T> = {
     isBase64Encoded?: boolean;
     statusCode: S;
     data: T;
@@ -242,7 +242,7 @@ export declare type ApiResponse<S extends number, T> = {
  *   { 'X-Frame-Options': 'DENY' }
  * );
  */
-export declare const apiJsonResponse: <S extends number, T extends JsonCompatibleStruct>(statusCode: S, data: T, headers?: HttpHeaders | undefined) => ApiResponse<S, T>;
+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
@@ -250,7 +250,7 @@ export declare const apiJsonResponse: <S extends number, T extends JsonCompatibl
  * @param headers HTTP headers
  * @example return apiTextResponse(200, 'some text')
  */
-export declare const apiTextResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders | undefined) => ApiResponse<S, string>;
+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
@@ -258,7 +258,7 @@ export declare const apiTextResponse: <S extends number>(statusCode: S, data: st
  * @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 | undefined) => ApiResponse<S, string>;
+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",

package/dist/esm/routing/validators/zod.d.ts

@@ -1,4 +1,4 @@
 import type { z } from 'zod';
-export declare const zodPayloadValidator: <T>(validator: z.ZodType<T, z.ZodTypeDef, T>) => (input: {
+export declare const zodPayloadValidator: <T extends {}>(validator: z.ZodType<T, T>) => (input: {
     [key: string]: any;
 }) => input is T;

package/dist/esm/routing/validators/zod.js

@@ -1,8 +1,10 @@
+/* spell-checker: ignore treeify */
+import { treeifyError } from 'zod';
 import { ValidationError } from '../../errors';
 export const zodPayloadValidator = (validator) => (input) => {
     const result = validator.safeParse(input);
     if (result.success) {
         return true;
     }
-    throw new ValidationError(result.error.format());
+    throw new ValidationError(treeifyError(result.error));
 };