@dereekb/firebase 13.11.14 → 13.11.16

package/src/lib/common/firestore/util/id.batch.d.ts

@@ -58,10 +58,11 @@ export type FirestoreIdBatchVerifierFactory<T, I extends PrimativeKey> = Factory
  * collection, respecting Firestore's `where('in')` limit of {@link FIRESTORE_MAX_WHERE_IN_FILTER_ARGS_COUNT}
  * items per query. This is used for batch ID generation to ensure uniqueness.
  *
+ * @param config - Specifies how to query for existing keys (by field or custom constraints)
+ * @returns A factory that produces verifiers bound to a specific collection.
+ *
  * @template T - The Firestore document data type
  * @template I - The identifier/key type
- * @param config - Specifies how to query for existing keys (by field or custom constraints)
- * @returns A factory that produces verifiers bound to a specific collection
  *
  * @example
  * ```ts
@@ -73,6 +74,7 @@ export type FirestoreIdBatchVerifierFactory<T, I extends PrimativeKey> = Factory
  * const verifier = factory(myCollection);
  * // verifier can now check batches of IDs for uniqueness
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firestoreIdBatchVerifierFactory<T, I extends PrimativeKey>(config: FirestoreIdBatchVerifierFactoryConfig<T, I>): FirestoreIdBatchVerifierFactory<T, I>;

package/src/lib/common/model/function.d.ts

@@ -40,8 +40,8 @@ export type OnCallTypeModelParamsFunction = <T>(modelTypeInput: FirestoreModelTy
  *
  * The returned function builds {@link OnCallTypedModelParams} for any model type.
  *
- * @param call - the CRUD call type to embed in generated params
- * @returns an {@link OnCallTypeModelParamsFunction} pre-configured with the given call type
+ * @param call - The CRUD call type to embed in generated params.
+ * @returns An {@link OnCallTypeModelParamsFunction} pre-configured with the given call type.
  * @throws {Error} When `modelType` is not provided or empty.
  *
  * @example
@@ -50,23 +50,10 @@ export type OnCallTypeModelParamsFunction = <T>(modelTypeInput: FirestoreModelTy
  * const params = createParams('notification', { title: 'Hello' });
  * // params === { call: 'create', modelType: 'notification', data: { title: 'Hello' } }
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function onCallTypedModelParamsFunction(call?: Maybe<OnCallFunctionType>): OnCallTypeModelParamsFunction;
-/**
- * Creates OnCallTypedModelParams for the input.
- *
- * Convenience function for calling onCallTypedModelParamsFunction and executing it with the input.
- *
- * @deprecated Move towards using onCallTypedModelParamsFunction directly with the call type instead of using this function. Will not be removed in the future.
- *
- * @param modelTypeInput - the model type string or ref
- * @param data - the call payload
- * @param specifier - optional sub-function specifier
- * @param call - the CRUD call type
- * @returns the constructed {@link OnCallTypedModelParams}
- */
-export declare function onCallTypedModelParams<T>(modelTypeInput: FirestoreModelType | FirestoreModelTypeRef, data: T, specifier?: string, call?: OnCallFunctionType): OnCallTypedModelParams<T>;
 /**
  * Pre-configured OnCallTypedModelParamsFunctions for 'create'
  */
@@ -193,8 +180,8 @@ export interface OnCallCreateModelResult {
 /**
  * Creates an {@link OnCallCreateModelResult} from document references by extracting their paths as model keys.
  *
- * @param result - document reference(s) from a create operation
- * @returns an {@link OnCallCreateModelResult} with model keys extracted from document paths
+ * @param result - Document reference(s) from a create operation.
+ * @returns An {@link OnCallCreateModelResult} with model keys extracted from document paths.
  *
  * @example
  * ```ts
@@ -206,7 +193,21 @@ export declare function onCallCreateModelResultWithDocs(result: ArrayOrValue<Doc
 /**
  * Creates an {@link OnCallCreateModelResult} from model key(s), normalizing to an array.
  *
- * @param modelKeys - the model key(s) of the created document(s)
- * @returns an {@link OnCallCreateModelResult} containing the keys as an array
+ * @param modelKeys - The model key(s) of the created document(s)
+ * @returns An {@link OnCallCreateModelResult} containing the keys as an array.
  */
 export declare function onCallCreateModelResult(modelKeys: ArrayOrValue<FirestoreModelKey>): OnCallCreateModelResult;
+/**
+ * Creates OnCallTypedModelParams for the input.
+ *
+ * Convenience function for calling onCallTypedModelParamsFunction and executing it with the input.
+ *
+ * @param modelTypeInput - The model type string or ref.
+ * @param data - The call payload.
+ * @param specifier - Optional sub-function specifier.
+ * @param call - The CRUD call type.
+ * @returns The constructed {@link OnCallTypedModelParams}
+ *
+ * @deprecated Move towards using onCallTypedModelParamsFunction directly with the call type instead of using this function. Will not be removed in the future.
+ */
+export declare function onCallTypedModelParams<T>(modelTypeInput: FirestoreModelType | FirestoreModelTypeRef, data: T, specifier?: string, call?: OnCallFunctionType): OnCallTypedModelParams<T>;

package/src/lib/common/model/model/model.loader.d.ts

@@ -37,8 +37,8 @@ export interface FirebaseModelLoader<C extends FirebaseModelLoaderContext, T, D
  *
  * Automatically uses a transaction accessor when the context has an active transaction.
  *
- * @param getFirestoreCollection - function to retrieve the Firestore collection from context
- * @returns a {@link FirebaseModelLoader} that loads document wrappers for given keys
+ * @param getFirestoreCollection - Function to retrieve the Firestore collection from context.
+ * @returns A {@link FirebaseModelLoader} that loads document wrappers for given keys.
  *
  * @example
  * ```ts

package/src/lib/common/model/model.service.d.ts

@@ -37,8 +37,8 @@ export interface FirebaseModelServiceConfig<C extends FirebaseModelServiceContex
 /**
  * Creates a {@link FirebaseModelService} that wires together model loading and permission evaluation.
  *
- * @param config - collection loader and role mapping functions
- * @returns a {@link FirebaseModelService} combining model loading and permission evaluation
+ * @param config - Collection loader and role mapping functions.
+ * @returns A {@link FirebaseModelService} combining model loading and permission evaluation.
  *
  * @example
  * ```ts
@@ -47,6 +47,7 @@ export interface FirebaseModelServiceConfig<C extends FirebaseModelServiceContex
  *   roleMapForModel: (output, context, model) => computeRoles(output, context)
  * });
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelService<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(config: FirebaseModelServiceConfig<C, T, D, R>): FirebaseModelService<C, T, D, R>;
@@ -57,8 +58,9 @@ export type FirebaseModelServiceFactory<C extends FirebaseModelServiceContext, T
 /**
  * Creates a {@link FirebaseModelServiceFactory} that lazily instantiates and caches the service.
  *
- * @param config - the service configuration
- * @returns a {@link FirebaseModelServiceFactory} that lazily creates and caches the service
+ * @param config - The service configuration.
+ * @returns A {@link FirebaseModelServiceFactory} that lazily creates and caches the service.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelServiceFactory<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(config: FirebaseModelServiceConfig<C, T, D, R>): FirebaseModelServiceFactory<C, T, D, R>;
@@ -104,8 +106,9 @@ export type InModelContextFirebaseModelServiceUseFunction<C extends FirebasePerm
  * The returned factory, when given a context, produces a callable service that can be invoked
  * with a model or key to perform permission-checked operations.
  *
- * @param factory - lazy getter for the underlying model service
- * @returns an {@link InContextFirebaseModelServiceFactory} that binds contexts to the service
+ * @param factory - Lazy getter for the underlying model service.
+ * @returns An {@link InContextFirebaseModelServiceFactory} that binds contexts to the service.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function inContextFirebaseModelServiceFactory<C extends FirebaseModelServiceContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(factory: FirebaseModelServiceGetter<C, T, D, R>): InContextFirebaseModelServiceFactory<C, T, D, R>;
@@ -146,8 +149,9 @@ export type FirebaseModelsServiceTypes<S extends FirebaseModelsService<any, any>
  * export const demoFirebaseModelServices = firebaseModelsService<typeof DEMO_FIREBASE_MODEL_SERVICE_FACTORIES, DemoFirebaseBaseContext, DemoFirebaseModelTypes>(DEMO_FIREBASE_MODEL_SERVICE_FACTORIES);
  * export type DemoFirebaseContext = DemoFirebaseBaseContext & { service: typeof demoFirebaseModelServices };
  *
- * @param services - the map of model service getter factories
- * @returns a {@link FirebaseModelsService} that dispatches to the appropriate model service by type
+ * @param services - Map of model service getter factories keyed by model type.
+ * @returns Aggregated {@link FirebaseModelsService} that dispatches by model type.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelsService<X extends FirebaseModelsServiceFactory<C, I>, C extends FirebaseModelServiceContext, I extends FirestoreModelIdentity = FirestoreModelIdentity>(services: X): FirebaseModelsService<X, C>;
@@ -164,8 +168,9 @@ export type InContextFirebaseModelsServiceFactory<Y> = FirebaseModelsServiceType
  *
  * The returned factory binds a context, so callers can then select individual model services by type.
  *
- * @param service - the multi-model service to wrap
- * @returns an {@link InContextFirebaseModelsServiceFactory} that binds a context to the service
+ * @param service - The multi-model service to wrap.
+ * @returns An {@link InContextFirebaseModelsServiceFactory} that binds a context to the service.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function inContextFirebaseModelsServiceFactory<X extends FirebaseModelsServiceFactory<C, I>, C extends FirebaseModelServiceContext, I extends FirestoreModelIdentity = FirestoreModelIdentity>(service: FirebaseModelsService<X, C>): InContextFirebaseModelsServiceFactory<FirebaseModelsService<X, C>>;
@@ -187,10 +192,11 @@ export type UseFirebaseModelsServiceSelectionUseFunction<Y extends FirebaseModel
 /**
  * Selects a model-bound service instance from a multi-model service by type and key.
  *
- * @param service - the multi-model service
- * @param type - the model type to select
- * @param select - selection params including context and key
- * @returns the {@link FirebaseModelsServiceSelectionResult} bound to the specified model
+ * @param service - The multi-model service.
+ * @param type - The model type to select.
+ * @param select - Selection params including context and key.
+ * @returns The {@link FirebaseModelsServiceSelectionResult} bound to the specified model.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function selectFromFirebaseModelsService<Y extends FirebaseModelsService<any, any>, T extends FirebaseModelsServiceTypes<Y>>(service: Y, type: T, select: FirebaseModelsServiceSelection<Y, T>): FirebaseModelsServiceSelectionResult<Y, T>;
@@ -199,10 +205,11 @@ export declare function selectFromFirebaseModelsService<Y extends FirebaseModels
  *
  * If roles are provided, uses `requireUse` to assert them. Otherwise, returns the basic `use` function.
  *
- * @param service - the multi-model service
- * @param type - the model type to select
- * @param select - selection params including context, key, and optional role requirements
- * @returns a {@link UsePromiseFunction} for the resolved roles reader
+ * @param service - The multi-model service.
+ * @param type - The model type to select.
+ * @param select - Selection params including context, key, and optional role requirements.
+ * @returns A {@link UsePromiseFunction} for the resolved roles reader.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function useFirebaseModelsService<Y extends FirebaseModelsService<any, any>, T extends FirebaseModelsServiceTypes<Y>>(service: Y, type: T, select: UseFirebaseModelsServiceSelection<Y, T>): UseFirebaseModelsServiceSelectionResult<Y, T>;
@@ -211,8 +218,9 @@ export declare function useFirebaseModelsService<Y extends FirebaseModelsService
  *
  * Useful for routing incoming requests to the correct model service by collection path.
  *
- * @param inContextFirebaseModelsService - context-bound multi-model service
- * @returns a map of collection type strings to their {@link FirestoreModelIdentity} objects
+ * @param inContextFirebaseModelsService - Context-bound multi-model service.
+ * @returns Map keyed by collection type, valued with the matching {@link FirestoreModelIdentity}.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function buildFirebaseCollectionTypeModelTypeMap<Y extends FirebaseModelsService<any, any>>(inContextFirebaseModelsService: InContextFirebaseModelsService<Y>): import("..").FirestoreModelIdentityTypeMap;

package/src/lib/common/model/permission/permission.service.d.ts

@@ -34,8 +34,9 @@ export declare class FirebaseModelPermissionServiceInstance<C extends FirebaseMo
 /**
  * Creates a {@link FirebaseModelPermissionServiceInstance} from a delegate.
  *
- * @param delegate - provides model loading and role computation
- * @returns a {@link FirebaseModelPermissionServiceInstance} configured with the given delegate
+ * @param delegate - Provides model loading and role computation.
+ * @returns A {@link FirebaseModelPermissionServiceInstance} configured with the given delegate.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseModelPermissionService<C extends FirebaseModelContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends string = string>(delegate: FirebasePermissionServiceInstanceDelegate<C, T, D, R>): FirebaseModelPermissionServiceInstance<C, T, D, R>;

package/src/lib/common/model/permission/permission.service.grant.d.ts

@@ -8,21 +8,22 @@ import { type UserRelated } from '../../../model/user';
  *
  * Returns `false` if no auth is present.
  *
- * @param context - the Firebase model context to evaluate
- * @returns a promise resolving to `true` if the user is an admin, `false` otherwise
+ * @param context - Firebase model context whose caller is evaluated.
+ * @returns Resolves with `true` for an admin caller, otherwise `false`.
  */
 export declare const isAdminInFirebaseModelContext: AsyncDecisionFunction<FirebaseModelContext>;
 /**
  * Creates a {@link GrantRolesIfFunction} that grants the specified roles when the user is an admin.
  *
- * @param rolesToGrantToAdmin - roles to grant if the user is an admin
- * @returns a {@link GrantRolesIfFunction} that grants the given roles when the user is an admin
+ * @param rolesToGrantToAdmin - Roles to grant if the user is an admin.
+ * @returns A {@link GrantRolesIfFunction} that grants the given roles when the user is an admin.
  *
  * @example
  * ```ts
  * const grantIfAdmin = grantModelRolesIfAdminFunction(fullAccessRoleMap);
  * const roles = await grantIfAdmin(context);
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfAdminFunction<R extends string = string>(rolesToGrantToAdmin: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<FirebaseModelContext, R>;
@@ -33,18 +34,19 @@ export declare const grantFullAccessIfAdmin: GeneralGrantRolesIfFunction<Firebas
 /**
  * Convenience function that evaluates admin status and grants roles in a single call.
  *
- * @param context - the model context to check
- * @param rolesToGrantToAdmin - roles to grant if admin
- * @param otherwise - fallback role computation when not admin
- * @returns a promise or value resolving to the granted role map
+ * @param context - Firebase model context whose caller is evaluated.
+ * @param rolesToGrantToAdmin - Roles granted when the caller is an admin.
+ * @param otherwise - Fallback computation invoked for non-admin callers.
+ * @returns Resolves with the granted role map.
  */
 export declare function grantModelRolesIfAdmin<R extends string = string>(context: FirebaseModelContext, rolesToGrantToAdmin: GetterOrValue<GrantedRoleMap<R>>, otherwise?: GrantRolesOtherwiseFunction<R>): PromiseOrValue<GrantedRoleMap<R>>;
 /**
  * Creates a {@link GrantRolesIfFunction} that grants roles when the user has all specified auth roles in their token.
  *
- * @param authRoles - the auth roles the user must have
- * @param rolesToGrantToAdmin - the model roles to grant if the auth roles are present
- * @returns a {@link GrantRolesIfFunction} that grants the given roles when the user has the required auth roles
+ * @param authRoles - The auth roles the user must have.
+ * @param rolesToGrantToAdmin - The model roles to grant if the auth roles are present.
+ * @returns A {@link GrantRolesIfFunction} that grants the given roles when the user has the required auth roles.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfHasAuthRolesFunction<R extends string = string>(authRoles: AuthRole[], rolesToGrantToAdmin: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<FirebaseModelContext, R>;
@@ -55,8 +57,9 @@ export type GrantModelRolesIfHasAuthRolesFactory = <R extends string = string>(c
 /**
  * Creates a reusable factory pre-configured with specific auth roles to check for.
  *
- * @param authRoles - the auth roles the user must have
- * @returns a {@link GrantModelRolesIfHasAuthRolesFactory} pre-configured to check the given auth roles
+ * @param authRoles - The auth roles the user must have.
+ * @returns A {@link GrantModelRolesIfHasAuthRolesFactory} pre-configured to check the given auth roles.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfHasAuthRolesFactory(authRoles: IterableOrValue<AuthRole>): GrantModelRolesIfHasAuthRolesFactory;
@@ -89,14 +92,15 @@ export declare const isOwnerOfUserRelatedModelInFirebaseModelContext: AsyncDecis
 /**
  * Creates a {@link GrantRolesIfFunction} that grants roles when the authenticated user's UID matches the model's `uid` field.
  *
- * @param rolesToGrant - the roles to grant if the user owns the model
- * @returns a {@link GrantRolesIfFunction} that grants roles when the authenticated user is the model owner
+ * @param rolesToGrant - The roles to grant if the user owns the model.
+ * @returns A {@link GrantRolesIfFunction} that grants roles when the authenticated user is the model owner.
  *
  * @example
  * ```ts
  * const grantIfOwner = grantModelRolesIfAuthUserRelatedModelFunction<User>(fullAccessRoleMap);
  * const roles = await grantIfOwner({ model: userData, context });
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfAuthUserRelatedModelFunction<T extends UserRelated, R extends string = string>(rolesToGrant: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<UserRelatedModelFirebaseModelContext<T>, R>;
@@ -117,9 +121,10 @@ export type GeneralGrantRolesOnlyIfFunction<C> = <R extends string = string>(con
 /**
  * Creates a {@link GrantRolesOnlyIfFunction} with no fallback — returns no-access if the condition is false.
  *
- * @param grantIf - decision function to evaluate
- * @param grantedRoles - roles to grant if the decision is `true`
- * @returns a {@link GrantRolesOnlyIfFunction} that grants roles or returns no-access with no fallback
+ * @param grantIf - Decision function to evaluate.
+ * @param grantedRoles - Roles to grant if the decision is `true`
+ * @returns A {@link GrantRolesOnlyIfFunction} that grants roles or returns no-access with no fallback.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesOnlyIfFunction<C, R extends string = string>(grantIf: AsyncDecisionFunction<C>, grantedRoles: GetterOrValue<GrantedRoleMap<R>>): GrantRolesOnlyIfFunction<C, R>;
@@ -144,9 +149,9 @@ export type GrantRolesOtherwiseFunction<R extends string = string> = Getter<Gran
  *
  * This is the core building block for composing permission logic.
  *
- * @param grantIf - async decision function to evaluate
- * @param grantedRoles - roles to grant if the decision is `true`
- * @returns a {@link GrantRolesIfFunction} that evaluates the condition and grants roles or falls back
+ * @param grantIf - Async decision function to evaluate.
+ * @param grantedRoles - Roles to grant if the decision is `true`
+ * @returns A {@link GrantRolesIfFunction} that evaluates the condition and grants roles or falls back.
  * @throws {Error} When `grantIf` is not provided.
  *
  * @example
@@ -157,6 +162,7 @@ export type GrantRolesOtherwiseFunction<R extends string = string> = Getter<Gran
  * );
  * const roles = await grantIfOwner(context, () => noAccessRoleMap());
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function grantModelRolesIfFunction<C, R extends string = string>(grantIf: AsyncDecisionFunction<C>, grantedRoles: GetterOrValue<GrantedRoleMap<R>>): GrantRolesIfFunction<C, R>;

package/src/lib/common/model/permission/permission.service.role.d.ts

@@ -54,22 +54,22 @@ export declare class ContextGrantedModelRolesReaderInstance<C extends FirebasePe
 /**
  * Creates a new ContextGrantedModelRolesReader for the input model.
  *
- * @param service - the in-model-context permission service to read roles from
- * @returns a promise resolving to a {@link ContextGrantedModelRolesReader} for the model
+ * @param service - In-model-context permission service whose role map is fetched.
+ * @returns Resolves with a {@link ContextGrantedModelRolesReader} bound to that model.
  */
 export declare function contextGrantedModelRolesReader<C extends FirebasePermissionErrorContext, T, D extends FirestoreDocument<T> = FirestoreDocument<T>, R extends GrantedRole = GrantedRole>(service: InModelContextFirebaseModelPermissionService<C, T, D, R>): Promise<ContextGrantedModelRolesReader<C, T, D, R>>;
 /**
  * Creates the default permission error message.
  *
- * @param contextGrantedModelRoles - the granted model roles context to generate the message from
- * @param roles - the required role(s) that were not satisfied
- * @returns a human-readable permission error message string
+ * @param contextGrantedModelRoles - The granted model roles context to generate the message from.
+ * @param roles - The required role(s) that were not satisfied.
+ * @returns A human-readable permission error message string.
  */
 export declare function contextGrantedModelRolesReaderPermissionErrorMessage(contextGrantedModelRoles: FirebaseContextGrantedModelRoles<FirebasePermissionErrorContext, unknown>, roles?: ArrayOrValue<GrantedRole>): string;
 /**
  * Creates the default does not exist error message.
  *
- * @param contextGrantedModelRoles - the granted model roles context to generate the message from
- * @returns a human-readable does-not-exist error message string
+ * @param contextGrantedModelRoles - The granted model roles context to generate the message from.
+ * @returns A human-readable does-not-exist error message string.
  */
 export declare function contextGrantedModelRolesReaderDoesNotExistErrorMessage(contextGrantedModelRoles: FirebaseContextGrantedModelRoles<FirebasePermissionErrorContext, unknown>): string;

package/src/lib/common/storage/accessor/path.model.d.ts

@@ -33,8 +33,8 @@ export type ModelStorageSlashPathFactory<T extends object = object> = (input: Re
  *
  * The generated paths follow the convention `/model/[basePath/]<modelKey>/[path]`.
  *
- * @param config - optional base path to nest under
- * @returns a {@link ModelStorageSlashPathFactory} that maps Firestore model keys to storage paths
+ * @param config - Optional base path to nest under.
+ * @returns A {@link ModelStorageSlashPathFactory} that maps Firestore model keys to storage paths.
  *
  * @example
  * ```ts
@@ -42,6 +42,7 @@ export type ModelStorageSlashPathFactory<T extends object = object> = (input: Re
  * const path = pathFactory(userDocument, 'profile.png');
  * // path === '/model/avatars/users/abc123/profile.png'
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function modelStorageSlashPathFactory<T extends object = object>(config?: ModelStorageSlashPathFactoryConfig): ModelStorageSlashPathFactory<T>;

package/src/lib/common/storage/context.d.ts

@@ -39,8 +39,8 @@ export interface FirebaseStorageContextFactoryConfig {
  * The returned factory resolves a default bucket (from driver, config, or error) and builds
  * a {@link StoragePathFactory} to normalize all path inputs.
  *
- * @param drivers - the storage driver implementations to use
- * @returns a {@link FirebaseStorageContextFactory} that creates storage contexts for a given storage instance
+ * @param drivers - The storage driver implementations to use.
+ * @returns A {@link FirebaseStorageContextFactory} that creates storage contexts for a given storage instance.
  * @throws {Error} When a default bucket ID cannot be resolved from the driver or config.
  *
  * @example
@@ -49,6 +49,7 @@ export interface FirebaseStorageContextFactoryConfig {
  * const storageContext = factory(firebaseStorage, { defaultBucketId: 'my-bucket' });
  * const file = storageContext.file('uploads/doc.pdf');
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function firebaseStorageContextFactory<F extends FirebaseStorage = FirebaseStorage>(drivers: FirebaseStorageDrivers): FirebaseStorageContextFactory<F>;

package/src/lib/common/storage/driver/accessor.iterate.d.ts

@@ -24,13 +24,14 @@ export type IterateStorageListFilesFactory = FetchPageFactory<IterateStorageList
  *
  * Wraps the folder's `list()` API with cursor-based pagination via {@link fetchPageFactory}.
  *
- * @param config - default listing options (e.g., maxResults)
- * @returns an {@link IterateStorageListFilesFactory} for paginated file listing
+ * @param config - Default listing options (e.g., maxResults)
+ * @returns An {@link IterateStorageListFilesFactory} for paginated file listing.
  *
  * @example
  * ```ts
  * const factory = iterateStorageListFilesFactory({ maxResults: 100 });
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function iterateStorageListFilesFactory(config: IterateStorageListFilesFactoryConfig): IterateStorageListFilesFactory;
@@ -44,8 +45,8 @@ export type IterateStorageListFilesByEachFileConfig<T, R> = Omit<IterateFetchPag
  *
  * Convenience wrapper around {@link iterateFetchPagesByEachItem} pre-configured for storage listing.
  *
- * @param input - iteration configuration including folder, listing options, and per-item callback
- * @returns the result of the paginated per-item iteration
+ * @param input - Iteration configuration including folder, listing options, and per-item callback.
+ * @returns The result of the paginated per-item iteration.
  */
 export declare function iterateStorageListFilesByEachFile<T, R>(input: IterateStorageListFilesByEachFileConfig<T, R>): Promise<{
     totalItemsLoaded: number;
@@ -63,7 +64,7 @@ export type IterateStorageListFilesConfig<R> = Omit<IterateFetchPagesConfigWithF
  *
  * Convenience wrapper around {@link iterateFetchPages} pre-configured for storage listing.
  *
- * @param input - iteration configuration including folder, listing options, and per-page callback
- * @returns the result of the paginated page-level iteration
+ * @param input - Iteration configuration including folder, listing options, and per-page callback.
+ * @returns The result of the paginated page-level iteration.
  */
 export declare function iterateStorageListFiles<R>(input: IterateStorageListFilesConfig<R>): Promise<import("@dereekb/util/fetch").IterateFetchPagesResult>;

package/src/lib/common/storage/driver/accessor.util.d.ts

@@ -6,10 +6,10 @@ import { type FirebaseStorageAccessorFile } from './accessor';
  *
  * This is a server-side convenience — most client implementations don't support `uploadStream()`.
  *
- * @param file - the target file accessor to upload to
- * @param readableStream - the source stream to pipe
- * @param options - optional upload configuration (content type, metadata, etc.)
- * @returns a promise that resolves when the upload stream has finished
+ * @param file - Destination file accessor for the upload.
+ * @param readableStream - Source stream piped into the upload.
+ * @param options - Overrides for content type, metadata, etc., if any.
+ * @returns Resolves once the upload stream has finished.
  * @throws {StorageFileUploadStreamUnsupportedError} When the file accessor does not support stream uploads.
  *
  * @example

package/src/lib/common/storage/driver/error.d.ts

@@ -5,15 +5,15 @@ import { BaseError } from 'make-error';
  *
  * Required when the upload input is a string, since the format (raw, base64, etc.) must be explicit.
  *
- * @param options - the upload options to extract from
- * @returns the {@link StorageDataStringType} extracted from the options
+ * @param options - The upload options to extract from.
+ * @returns The {@link StorageDataStringType} extracted from the options.
  * @throws {Error} When `stringFormat` is not set in the options.
  */
 export declare function assertStorageUploadOptionsStringFormat(options?: StorageUploadOptions): StorageDataStringType;
 /**
  * Creates an error indicating that `stringFormat` was missing from upload options.
  *
- * @returns an {@link Error} describing the missing `stringFormat` in upload options
+ * @returns An {@link Error} describing the missing `stringFormat` in upload options.
  */
 export declare function noStringFormatInStorageUploadOptionsError(): Error;
 /**

package/src/lib/common/storage/driver/list.d.ts

@@ -41,8 +41,8 @@ export type StorageListFilesResultFactory<S, R> = (input: StorageListFilesResult
  * The returned factory lazily computes file and folder arrays (via {@link cachedGetter}) and
  * provides cursor-based pagination through the `next()` method.
  *
- * @param delegate - platform-specific implementation for extracting results
- * @returns a {@link StorageListFilesResultFactory} that normalizes raw SDK list results
+ * @param delegate - Platform-specific implementation for extracting results.
+ * @returns A {@link StorageListFilesResultFactory} that normalizes raw SDK list results.
  *
  * @example
  * ```ts
@@ -50,12 +50,13 @@ export type StorageListFilesResultFactory<S, R> = (input: StorageListFilesResult
  * const result = factory({ storage, folder, options: { maxResults: 50 } }, rawSdkResult);
  * const files = result.files();
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function storageListFilesResultFactory<S, R>(delegate: StorageListFilesResultFactoryDelegate<S, R>): StorageListFilesResultFactory<S, R>;
 /**
  * Creates an error thrown when `next()` is called on a list result that has no more pages.
  *
- * @returns an {@link Error} indicating there are no more pages to fetch
+ * @returns An {@link Error} indicating there are no more pages to fetch.
  */
 export declare function storageListFilesResultHasNoNextError(): Error;

package/src/lib/common/storage/storage.d.ts

@@ -45,8 +45,8 @@ export interface StoragePath extends StorageBucketIdRef, StorageSlashPathRef {
  *
  * Useful when you need an independent reference that won't be affected by mutations to the original.
  *
- * @param path - the storage path to copy
- * @returns a new {@link StoragePath} with the same `bucketId` and `pathString`
+ * @param path - The storage path to copy.
+ * @returns A new {@link StoragePath} with the same `bucketId` and `pathString`
  *
  * @example
  * ```ts
@@ -79,8 +79,8 @@ export interface StoragePathFactoryConfig extends StorageBucketIdRef {
  * Creates a {@link StoragePathFactory} that normalizes various path inputs into {@link StoragePath} objects
  * with a consistent bucket assignment.
  *
- * @param config - bucket and replacement behavior
- * @returns a {@link StoragePathFactory} that normalizes path inputs with the configured bucket
+ * @param config - Bucket and replacement behavior.
+ * @returns A {@link StoragePathFactory} that normalizes path inputs with the configured bucket.
  *
  * @example
  * ```ts
@@ -88,6 +88,7 @@ export interface StoragePathFactoryConfig extends StorageBucketIdRef {
  * const path = pathFactory('images/photo.png');
  * // path === { bucketId: 'my-bucket', pathString: 'images/photo.png' }
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function storagePathFactory(config: StoragePathFactoryConfig): StoragePathFactory;
@@ -119,8 +120,8 @@ export type GoogleCloudStorageFilePath<P extends StorageSlashPath = StorageSlash
  * If the path has a bucketId, produces a `gs://bucket/path` URI. Otherwise, returns just the relative path
  * (implying the default bucket).
  *
- * @param path - the storage path to convert
- * @returns a {@link GoogleCloudStorageFilePath} string (`gs://bucket/path` or a relative path)
+ * @param path - The storage path to convert.
+ * @returns A {@link GoogleCloudStorageFilePath} string (`gs://bucket/path` or a relative path)
  *
  * @example
  * ```ts
@@ -132,8 +133,8 @@ export declare function firebaseStorageFilePathFromStorageFilePath(path: Storage
 /**
  * Returns the `gs://` bucket prefix URI for the given bucket identifier or ref.
  *
- * @param storage - bucket ID string or a {@link StorageBucketIdRef}
- * @returns the `gs://bucket` prefix URI as a {@link GoogleCloudStorageBucketPrefix}
+ * @param storage - Bucket ID string or a {@link StorageBucketIdRef}
+ * @returns The `gs://bucket` prefix URI as a {@link GoogleCloudStorageBucketPrefix}
  *
  * @example
  * ```ts

package/src/lib/common/storage/types.d.ts

@@ -362,7 +362,7 @@ export interface StorageMetadata extends ConfigurableStorageMetadata {
  * Additional user-defined custom metadata.
  */
 export type StorageCustomMetadata = {
-    readonly [key: string]: string | null;
+    readonly [key: string]: Maybe<string>;
 };
 export interface StorageDeleteFileOptions {
     /**

package/src/lib/model/notification/notification.api.d.ts

@@ -303,7 +303,7 @@ export interface CleanupOldNotificationLoggedEventDaysResult {
  * Custom (non-CRUD) function type map for notifications. Currently empty — all operations use the CRUD pattern.
  */
 export type NotificationFunctionTypeMap = {};
-export declare const notificationFunctionTypeConfigMap: FirebaseFunctionTypeConfigMap<NotificationFunctionTypeMap>;
+export declare const NOTIFICATION_FUNCTION_TYPE_CONFIG_MAP: FirebaseFunctionTypeConfigMap<NotificationFunctionTypeMap>;
 export type NotificationBoxModelCrudFunctionsConfig = {
     readonly notificationUser: {
         update: {
@@ -331,7 +331,7 @@ export type NotificationBoxModelCrudFunctionsConfig = {
     readonly notificationLoggedEventDay: null;
     readonly notificationLoggedEventDayPage: null;
 };
-export declare const notificationBoxModelCrudFunctionsConfig: ModelFirebaseCrudFunctionConfigMap<NotificationBoxModelCrudFunctionsConfig, NotificationTypes>;
+export declare const NOTIFICATION_BOX_MODEL_CRUD_FUNCTIONS_CONFIG: ModelFirebaseCrudFunctionConfigMap<NotificationBoxModelCrudFunctionsConfig, NotificationTypes>;
 /**
  * Abstract client-callable function map for notification CRUD operations.
  *