@openstax/ts-utils 1.28.1 → 1.30.0

package/dist/esm/services/accountsGateway/index.d.ts

@@ -3,7 +3,7 @@ import { GenericFetch } from '../../fetch';
 import { JsonCompatibleStruct } from '../../routing';
 import { ApiUser, ConsentPreferences } from '../authProvider';
 import { Logger } from '../logger';
-export declare type Config = {
+export type Config = {
     accountsBase: string;
     accountsAuthToken: string;
 };
@@ -11,14 +11,14 @@ interface Initializer<C> {
     configSpace?: C;
     fetch: GenericFetch;
 }
-export declare type FindUserPayload = ({
+export type FindUserPayload = ({
     external_id: string;
 } | {
     uuid: string;
 }) & {
     sso?: string;
 };
-export declare type FindOrCreateUserPayload = {
+export type FindOrCreateUserPayload = {
     external_id: string;
     email?: string;
     already_verified?: boolean;
@@ -32,45 +32,42 @@ export declare type FindOrCreateUserPayload = {
     is_test?: boolean;
     sso?: string;
 };
-export declare type FindOrCreateUserResponse = {
+export type FindOrCreateUserResponse = {
     id: number;
     uuid: string;
     external_ids: string[];
     is_test: boolean;
     sso: string;
 };
-export declare type FindUserResponse = (FindOrCreateUserResponse & {
+export type FindUserResponse = (FindOrCreateUserResponse & {
     external_ids: string[];
 }) | undefined;
-export declare type LinkUserPayload = {
+export type LinkUserPayload = {
     userId: number;
     externalId: string;
 };
-export declare type LinkUserResponse = {
+export type LinkUserResponse = {
     user_id: number;
     external_id: string;
 };
-export declare type SearchUsersPayload = {
+export type SearchUsersPayload = {
     q: string;
     order_by?: string;
 };
-export declare type SearchUsersResponse = {
+export type SearchUsersResponse = {
     items: Array<ApiUser & {
         external_ids: string[];
     } & JsonCompatibleStruct>;
     total_count: number;
 };
-export declare type UpdateUserPayload = ConsentPreferences;
-export declare type MappedUserInfo<T> = {
+export type UpdateUserPayload = ConsentPreferences;
+export type MappedUserInfo<T> = {
     data: T;
     fullName: string;
     platformUserId?: string;
     uuid: string;
 };
-export declare const accountsGateway: <C extends string = "accounts">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    accountsBase: import("../../config").ConfigValueProvider<string>;
-    accountsAuthToken: import("../../config").ConfigValueProvider<string>;
-}; }) => ({ logger }: {
+export declare const accountsGateway: <C extends string = "accounts">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => ({ logger }: {
     logger: Logger;
 }) => {
     findOrCreateUser: (body: FindOrCreateUserPayload) => Promise<FindOrCreateUserResponse>;
@@ -79,7 +76,7 @@ export declare const accountsGateway: <C extends string = "accounts">(initialize
     linkUser: (body: LinkUserPayload) => Promise<LinkUserResponse>;
     mapUserUuids: <T>(userUuidsMap: {
         [uuid: string]: T;
-    }, platformId?: string | undefined) => Promise<{
+    }, platformId?: string) => Promise<{
         data: T;
         fullName: string;
         platformUserId: string | undefined;
@@ -87,9 +84,9 @@ export declare const accountsGateway: <C extends string = "accounts">(initialize
     }[]>;
     searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
     updateUser: (token: string, body: UpdateUserPayload) => Promise<ApiUser & JsonCompatibleStruct>;
-    getUserMap: <R>(userUuids: Set<string>, mapper: (user: ApiUser) => R) => Promise<Map<string, R>>;
-    mapUserData: <T_1, R_1>(input: T_1[], getUserUuid: (item: T_1) => string, mapper: (user: ApiUser | undefined, item: T_1) => R_1) => Promise<R_1[]>;
-    mapUsersData: <T_2, R_2>(input: T_2[], getUserUuids: (item: T_2) => string[], mapper: (users: Map<string, ApiUser | undefined>, item: T_2) => R_2) => Promise<R_2[]>;
+    getUserMap: <R>(userUuids: Set<string>, mapper: ((user: ApiUser) => R)) => Promise<Map<string, R>>;
+    mapUserData: <T, R>(input: T[], getUserUuid: (item: T) => string, mapper: ((user: ApiUser | undefined, item: T) => R)) => Promise<R[]>;
+    mapUsersData: <T, R_1>(input: T[], getUserUuids: (item: T) => string[], mapper: ((users: Map<string, ApiUser | undefined>, item: T) => R_1)) => Promise<R_1[]>;
 };
-export declare type AccountsGateway = ReturnType<ReturnType<ReturnType<typeof accountsGateway>>>;
+export type AccountsGateway = ReturnType<ReturnType<ReturnType<typeof accountsGateway>>>;
 export {};

package/dist/esm/services/apiGateway/index.d.ts

@@ -4,9 +4,9 @@ import { ConfigForFetch, GenericFetch, Response } from '../../fetch';
 import { AnyRoute, ApiResponse, OutputForRoute, ParamsForRoute, PayloadForRoute, QueryParams } from '../../routing';
 import { UnwrapPromise } from '../../types';
 import { Logger } from '../logger';
-export declare type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
-export declare type TResponseStatus<R> = R extends ApiResponse<infer S, any> ? S : never;
-export declare type RouteClient<R> = {
+export type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
+export type TResponseStatus<R> = R extends ApiResponse<infer S, any> ? S : never;
+export type RouteClient<R> = {
     (config: {
         fetchConfig?: any;
         query?: QueryParams;
@@ -25,27 +25,27 @@ export interface AcceptStatus<Ro> {
     <S extends TResponseStatus<Ro>[]>(...args: S): Promise<ApiClientResponse<Extract<Ro, Record<'statusCode', S[number]>>>>;
     <S extends number[]>(...args: S): Promise<ApiClientResponse<any>>;
 }
-export declare type UnsafeApiClientResponse<Ro> = {
+export type UnsafeApiClientResponse<Ro> = {
     headers: Headers;
     load: () => Promise<any>;
     status: number;
     acceptStatus: AcceptStatus<Ro>;
 };
-export declare type ApiClientResponse<Ro> = Ro extends any ? {
+export type ApiClientResponse<Ro> = Ro extends any ? {
     headers: Headers;
     status: TResponseStatus<Ro>;
     load: () => Promise<TResponsePayload<Ro>>;
 } : never;
-export declare type ExpandRoute<T> = T extends ((...args: infer A) => infer R) & {
+export type ExpandRoute<T> = T extends ((...args: infer A) => infer R) & {
     renderUrl: (...args: infer Ar) => Promise<string>;
 } ? (...args: A) => R & {
     renderUrl: (...args: Ar) => Promise<string>;
 } : never;
-export declare type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+export type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
     [N in Ru['name']]: ExpandRoute<RouteClient<Extract<Ru, Record<'name', N>>>>;
 } : never;
-export declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
-    [N in Ru['name']]: {
+export type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+    [_N in Ru['name']]: {
         path: string;
         method: string;
     };
@@ -63,6 +63,6 @@ export interface MakeApiGateway<F> {
         launchToken?: string;
     }): MapRoutesToClient<Ru>;
 }
-export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {
+export declare const createApiGateway: <F extends GenericFetch>(initializer: {
     fetch: F;
 }) => MakeApiGateway<F>;

package/dist/esm/services/authProvider/browser.d.ts

@@ -1,14 +1,14 @@
 import { ConfigProviderForConfig } from '../../config';
 import { FetchConfig, GenericFetch } from '../../fetch';
 import { User } from '.';
-declare type Config = {
+type Config = {
     accountsBase: string;
 };
 interface Initializer<C> {
     configSpace?: C;
     window: Window;
 }
-export declare type EventHandler = (e: {
+export type EventHandler = (e: {
     data: any;
     origin: string;
     source: Pick<Window, 'postMessage'>;
@@ -26,10 +26,8 @@ export interface Window {
     addEventListener: (event: 'message', callback: EventHandler) => void;
     removeEventListener: (event: 'message', callback: EventHandler) => void;
 }
-export declare type UpdatableUserFields = Partial<Pick<User, 'consent_preferences' | 'first_name' | 'last_name'>>;
-export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [key in C]: {
-    accountsBase: import("../../config").ConfigValueProvider<string>;
-}; }) => {
+export type UpdatableUserFields = Partial<Pick<User, 'consent_preferences' | 'first_name' | 'last_name'>>;
+export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => {
     /**
      * gets the authentication token
      */
@@ -54,7 +52,7 @@ export declare const browserAuthProvider: <C extends string = "auth">({ window,
      */
     getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
         [key: string]: string;
-    } | undefined) => string;
+    }) => string;
     /**
      * gets second argument for `fetch` that has authentication token or cookie
      */

package/dist/esm/services/authProvider/decryption.d.ts

@@ -1,6 +1,6 @@
 import type { ConfigProviderForConfig } from '../../config';
 import { AuthProvider, CookieAuthProvider } from '.';
-declare type Config = {
+type Config = {
     cookieName: string;
     encryptionPrivateKey: string;
     signaturePublicKey: string;
@@ -8,12 +8,8 @@ declare type Config = {
 interface Initializer<C> {
     configSpace?: C;
 }
-export declare type DecryptionAuthProvider = AuthProvider & {
+export type DecryptionAuthProvider = AuthProvider & {
     getTokenExpiration: (tokenString?: string) => Promise<number | null | undefined>;
 };
-export declare const decryptionAuthProvider: <C extends string = "decryption">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    cookieName: import("../../config").ConfigValueProvider<string>;
-    encryptionPrivateKey: import("../../config").ConfigValueProvider<string>;
-    signaturePublicKey: import("../../config").ConfigValueProvider<string>;
-}; }) => CookieAuthProvider<DecryptionAuthProvider>;
+export declare const decryptionAuthProvider: <C extends string = "decryption">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => CookieAuthProvider<DecryptionAuthProvider>;
 export {};

package/dist/esm/services/authProvider/index.d.ts

@@ -1,13 +1,13 @@
 import type { FetchConfig } from '../../fetch';
 import type { HttpHeaders, QueryParams } from '../../routing';
 import type { Logger } from '../logger';
-export declare type ConsentPreferences = {
+export type ConsentPreferences = {
     consent_preferences: {
         accepted: string[];
         rejected: string[];
     };
 };
-export declare type TokenUser = {
+export type TokenUser = {
     id: number;
     name: string;
     first_name: string;
@@ -35,8 +35,8 @@ export interface ApiUser extends TokenUser {
     signed_contract_names: string[];
     using_openstax: boolean;
 }
-export declare type User = TokenUser | ApiUser;
-export declare type AuthProvider = {
+export type User = TokenUser | ApiUser;
+export type AuthProvider = {
     getAuthToken: () => Promise<string | null>;
     getUser: () => Promise<User | undefined>;
     /**
@@ -44,17 +44,17 @@ export declare type AuthProvider = {
      */
     getAuthorizedFetchConfig: () => Promise<FetchConfig>;
 };
-export declare type CookieAuthProviderRequest = {
+export type CookieAuthProviderRequest = {
     cookies?: string[];
     headers: HttpHeaders;
     queryStringParameters?: QueryParams;
 };
-export declare type CookieAuthProvider<T extends AuthProvider = AuthProvider> = (inputs: {
+export type CookieAuthProvider<T extends AuthProvider = AuthProvider> = (inputs: {
     request: CookieAuthProviderRequest;
     logger: Logger;
 }) => T;
-export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
-export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;
+export type StubAuthProvider = (user: User | undefined) => AuthProvider;
+export declare const stubAuthProvider: (user?: User) => AuthProvider;
 export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string, queryKey?: string) => [string, {
     Authorization: string;
 }] | [string, {

package/dist/esm/services/authProvider/subrequest.d.ts

@@ -1,7 +1,7 @@
 import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
 import { CookieAuthProvider } from '.';
-declare type Config = {
+type Config = {
     cookieName: string;
     accountsBase: string;
 };
@@ -9,8 +9,5 @@ interface Initializer<C> {
     configSpace?: C;
     fetch: GenericFetch;
 }
-export declare const subrequestAuthProvider: <C extends string = "subrequest">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    cookieName: import("../../config").ConfigValueProvider<string>;
-    accountsBase: import("../../config").ConfigValueProvider<string>;
-}; }) => CookieAuthProvider;
+export declare const subrequestAuthProvider: <C extends string = "subrequest">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => CookieAuthProvider;
 export {};

package/dist/esm/services/authProvider/utils/decryptAndVerify.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" />
 import type { User } from '..';
 export declare const decryptJwe: (jwe: string, encryptionPrivateKey: Buffer | string) => string | undefined;
-declare type MaybeAccountsSSOToken = {
+type MaybeAccountsSSOToken = {
     iss?: string;
     sub?: User | string;
     aud?: string;

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -1,10 +1,10 @@
 import { User } from '..';
 import { Window } from '../browser';
-export declare type UserData = {
+export type UserData = {
     user?: User;
     token: string | null;
 };
-declare type UserDataLoader = () => Promise<UserData>;
+type UserDataLoader = () => Promise<UserData>;
 export declare enum PostMessageTypes {
     ReceiveUser = "receive-user",
     RequestUser = "request-user"
@@ -13,14 +13,14 @@ export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { authQ
     authQuery?: {
         key: string;
         value: string | null;
-    } | undefined;
+    };
     window: Window;
 }) => {
     embeddedQueryKey: string;
     embeddedQueryValue: string;
     getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
         [key: string]: string;
-    } | undefined) => string;
+    }) => string;
     unmount: () => void;
 };
 export {};

package/dist/esm/services/authProvider/utils/userRoleValidator.d.ts

@@ -1,7 +1,7 @@
 import { AuthProvider } from '..';
 import { AssertionFailed } from '../../../assertions';
 import { ConfigProviderForConfig } from '../../../config';
-declare type Config = {
+type Config = {
     application: string;
 };
 export declare const createUserRoleValidator: (auth: AuthProvider, config: ConfigProviderForConfig<Config>) => {
@@ -9,5 +9,5 @@ export declare const createUserRoleValidator: (auth: AuthProvider, config: Confi
     userHasRole: (role: string[]) => Promise<boolean>;
     assertUserRole: (role: string[], fail?: AssertionFailed) => Promise<void>;
 };
-export declare type UserRoleValidator = ReturnType<typeof createUserRoleValidator>;
+export type UserRoleValidator = ReturnType<typeof createUserRoleValidator>;
 export {};

package/dist/esm/services/documentStore/index.d.ts

@@ -1,14 +1,14 @@
-export declare type Config = {
+export type Config = {
     tableName: string;
 };
-export declare type DocumentBaseMapType = {
+export type DocumentBaseMapType = {
     [key: string]: DocumentBaseValueTypes;
 };
-export declare type DocumentBaseListType = DocumentBaseValueTypes[];
-export declare type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
-export declare type DocumentBaseType = {
+export type DocumentBaseListType = DocumentBaseValueTypes[];
+export type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
+export type DocumentBaseType = {
     [key: string]: DocumentBaseValueTypes;
 };
-export declare type TDocument<T> = {
-    [k in keyof T]: DocumentBaseValueTypes;
+export type TDocument<T> = {
+    [_key in keyof T]: DocumentBaseValueTypes;
 };

package/dist/esm/services/documentStore/unversioned/dynamodb.d.ts

@@ -5,14 +5,12 @@ interface Initializer<C> {
     configSpace?: C;
     dynamoClient?: DynamoDB;
 }
-export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
-    tableName: import("../../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
-    afterWrite?: ((item: T) => void | Promise<void>) | undefined;
-    batchAfterWrite?: ((items: T[]) => void | Promise<void>) | undefined;
-} | undefined) => {
+export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    batchAfterWrite?: (items: T[]) => void | Promise<void>;
+}) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
-    getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string) => Promise<{
         items: T[];
         nextPageToken: string | undefined;
     }>;
@@ -24,10 +22,10 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     createItem: (item: T) => Promise<T>;
     batchCreateItem: (items: T[], concurrency?: number) => Promise<{
         successful: T[];
-        failed: {
+        failed: Array<{
             item: T;
             error: Error;
-        }[];
+        }>;
     }>;
 };
 export {};

package/dist/esm/services/documentStore/unversioned/file-system.d.ts

@@ -5,14 +5,12 @@ interface Initializer<C> {
     fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
     configSpace?: C;
 }
-export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
-    tableName: import("../../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
-    afterWrite?: ((item: T) => void | Promise<void>) | undefined;
-    batchAfterWrite?: ((items: T[]) => void | Promise<void>) | undefined;
-} | undefined) => {
+export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    batchAfterWrite?: (items: T[]) => void | Promise<void>;
+}) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
-    getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string) => Promise<{
         items: T[];
         nextPageToken: string | undefined;
     }>;
@@ -24,10 +22,10 @@ export declare const fileSystemUnversionedDocumentStore: <C extends string = "fi
     createItem: (item: T) => Promise<T>;
     batchCreateItem: (items: T[], _concurrency?: number) => Promise<{
         successful: T[];
-        failed: {
+        failed: Array<{
             item: T;
             error: Error;
-        }[];
+        }>;
     }>;
 };
 export {};

package/dist/esm/services/documentStore/unversioned/index.d.ts

@@ -1,2 +1,2 @@
 import { dynamoUnversionedDocumentStore } from './dynamodb';
-export declare type UnversionedDocumentStoreCreator = typeof dynamoUnversionedDocumentStore;
+export type UnversionedDocumentStoreCreator = typeof dynamoUnversionedDocumentStore;

package/dist/esm/services/documentStore/versioned/dynamodb.d.ts

@@ -6,21 +6,19 @@ interface Initializer<C> {
     configSpace?: C;
     dynamoClient?: DynamoDB;
 }
-export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends VersionedTDocument<T>>() => (configProvider: { [key in C]: {
-    tableName: import("../../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, options?: {
-    afterWrite?: ((item: T) => void | Promise<void>) | undefined;
-    getAuthor?: A | undefined;
-} | undefined) => {
+export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T, A extends undefined | ((...a: any[]) => Promise<VersionedDocumentAuthor>)>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    getAuthor?: A;
+}) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
-    getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
+    getVersions: (id: T[K], startVersion?: number) => Promise<{
         items: T[];
         nextPageToken: number | undefined;
     } | undefined>;
-    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    getItem: (id: T[K], timestamp?: number) => Promise<T | undefined>;
     prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
         document: T;
-        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">>) => Promise<T>;
     }>;
     putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
 };

package/dist/esm/services/documentStore/versioned/file-system.d.ts

@@ -6,20 +6,18 @@ interface Initializer<C> {
     fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
     configSpace?: C;
 }
-export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [key in C]: {
-    tableName: import("../../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, options?: {
-    getAuthor?: A | undefined;
-} | undefined) => {
+export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T, A extends undefined | ((...a: any[]) => Promise<VersionedDocumentAuthor>)>(_: {}, hashKey: K, options?: {
+    getAuthor?: A;
+}) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
-    getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
+    getVersions: (id: T[K], startVersion?: number) => Promise<{
         items: T[];
         nextPageToken: number | undefined;
     } | undefined>;
-    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    getItem: (id: T[K], timestamp?: number) => Promise<T | undefined>;
     prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
         document: T;
-        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">>) => Promise<T>;
     }>;
     putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
 };

package/dist/esm/services/documentStore/versioned/index.d.ts

@@ -1,6 +1,6 @@
 import { TDocument } from '..';
 import { dynamoVersionedDocumentStore } from './dynamodb';
-export declare type VersionedDocumentAuthor = {
+export type VersionedDocumentAuthor = {
     type: 'user';
     uuid: string;
     name: string;
@@ -9,9 +9,9 @@ export declare type VersionedDocumentAuthor = {
     type: 'system';
     reason: string;
 };
-export declare type VersionedDocumentRequiredFields = {
+export type VersionedDocumentRequiredFields = {
     timestamp: number;
     author: VersionedDocumentAuthor;
 };
-export declare type VersionedTDocument<T> = TDocument<T> & VersionedDocumentRequiredFields;
-export declare type VersionedDocumentStoreCreator = typeof dynamoVersionedDocumentStore;
+export type VersionedTDocument<T> = TDocument<T> & VersionedDocumentRequiredFields;
+export type VersionedDocumentStoreCreator = typeof dynamoVersionedDocumentStore;

package/dist/esm/services/exercisesGateway/index.d.ts

@@ -1,6 +1,6 @@
 import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
-export declare type Config = {
+export type Config = {
     defaultCorrectness?: string;
     exercisesHost: string;
     exercisesAuthToken: string;
@@ -9,18 +9,18 @@ interface Initializer<C> {
     configSpace?: C;
     fetch: GenericFetch;
 }
-export declare type Answer = {
+export type Answer = {
     id: number;
     content_html: string;
     correctness?: string;
     feedback_html?: string;
 };
-export declare type Solution = {
+export type Solution = {
     images: any[];
     solution_type: string;
     content_html: string;
 };
-export declare type Question = {
+export type Question = {
     id: number;
     is_answer_order_important: boolean;
     stimulus_html: string;
@@ -32,7 +32,7 @@ export declare type Question = {
     collaborator_solutions?: Solution[];
     community_solutions?: Solution[];
 };
-export declare type Exercise = {
+export type Exercise = {
     images: any[];
     tags: string[];
     uuid: string;
@@ -51,21 +51,17 @@ export declare type Exercise = {
     versions: number[];
     stimulus_html: string;
 };
-export declare type ExercisesSearchResults = {
+export type ExercisesSearchResults = {
     total_count: number;
     items: Exercise[];
 };
-export declare type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
+export type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
     digest: string;
 };
-export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
-    exercisesHost: import("../../config").ConfigValueProvider<string>;
-    exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
-}; }) => (_: {}) => {
+export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => (_: {}) => {
     searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
     get: (uuid: string) => Promise<Exercise | undefined>;
     search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
 };
-export declare type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
+export type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
 export {};

package/dist/esm/services/fileServer/index.d.ts

@@ -1,11 +1,10 @@
-/// <reference types="node" />
-export declare type FileValue = {
+export type FileValue = {
     dataType: 'file';
     mimeType: string;
     path: string;
     label: string;
 };
-export declare type FolderValue = {
+export type FolderValue = {
     dataType: 'folder';
     files: FileValue[];
 };

package/dist/esm/services/fileServer/localFileServer.d.ts

@@ -1,6 +1,6 @@
 import { ConfigProviderForConfig } from '../../config';
 import { FileServerAdapter } from '.';
-export declare type Config = {
+export type Config = {
     port?: string;
     host?: string;
     storagePrefix: string;
@@ -9,9 +9,5 @@ interface Initializer<C> {
     dataDir: string;
     configSpace?: C;
 }
-export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    port?: import("../../config").ConfigValueProvider<string> | undefined;
-    host?: import("../../config").ConfigValueProvider<string> | undefined;
-    storagePrefix: import("../../config").ConfigValueProvider<string>;
-}; }) => FileServerAdapter;
+export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => FileServerAdapter;
 export {};

package/dist/esm/services/fileServer/s3FileServer.d.ts

@@ -1,7 +1,7 @@
 import { S3Client } from '@aws-sdk/client-s3';
 import { ConfigProviderForConfig } from '../../config';
 import { FileServerAdapter } from '.';
-export declare type Config = {
+export type Config = {
     bucketName: string;
     bucketRegion: string;
 };
@@ -9,8 +9,5 @@ interface Initializer<C> {
     configSpace?: C;
     getS3Client?: (...args: ConstructorParameters<typeof S3Client>) => S3Client;
 }
-export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    bucketName: import("../../config").ConfigValueProvider<string>;
-    bucketRegion: import("../../config").ConfigValueProvider<string>;
-}; }) => FileServerAdapter;
+export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => FileServerAdapter;
 export {};