@dereekb/firebase 11.0.21 → 11.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/firebase",
-  "version": "11.0.21",
+  "version": "11.1.0",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
@@ -30,7 +30,8 @@
     "firebase": "^10.5.0",
     "ts-essentials": "^9.1.2",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.0"
+    "class-validator": "^0.14.0",
+    "date-fns": "^2.30.0"
   },
   "dependencies": {},
   "module": "./index.esm.js",

package/src/lib/client/error/error.d.ts

@@ -0,0 +1,8 @@
+import { type FirebaseError } from 'firebase/app';
+/**
+ * Returns true if the input is seen as a client-side FirebaseError.
+ *
+ * @param error
+ * @returns
+ */
+export declare function isClientFirebaseError(error: any): error is FirebaseError;

package/src/lib/client/error/index.d.ts

@@ -0,0 +1 @@
+export * from './error';

package/src/lib/client/firestore/error.d.ts

@@ -0,0 +1 @@
+export declare const FIRESTORE_PERMISSION_DENIED_ERROR_CODE: string;

package/src/lib/client/firestore/index.d.ts

@@ -1,5 +1,6 @@
 export * from './driver';
 export * from './driver.accessor';
 export * from './driver.query';
+export * from './error';
 export * from './firestore';
 export * from './increment';

package/src/lib/client/index.d.ts

@@ -1,3 +1,4 @@
+export * from './error';
 export * from './firestore';
 export * from './function';
 export * from './storage';

package/src/lib/common/firestore/accessor/document.utility.d.ts

@@ -41,6 +41,10 @@ export interface FirestoreDocumentSnapshotDataPairWithData<D extends FirestoreDo
 }
 export declare function getDocumentSnapshotDataPair<D extends FirestoreDocument<any>>(document: D): Promise<FirestoreDocumentSnapshotDataPair<D>>;
 export declare function getDocumentSnapshotDataPairs<D extends FirestoreDocument<any>>(documents: D[]): Promise<FirestoreDocumentSnapshotDataPair<D>[]>;
+/**
+ * Convenience function for calling getDocumentSnapshotDataPairs() then returning only the pairs that have data.
+ */
+export declare function getDocumentSnapshotDataPairsWithData<D extends FirestoreDocument<any>>(documents: D[]): Promise<FirestoreDocumentSnapshotDataPairWithData<D>[]>;
 export type FirestoreDocumentSnapshotDataTuple<D extends FirestoreDocument<any>> = [D, Maybe<FirestoreDocumentData<D>>];
 export declare function getDocumentSnapshotDataTuples<D extends FirestoreDocument<any>>(documents: D[]): Promise<FirestoreDocumentSnapshotDataTuple<D>[]>;
 export declare function getDocumentSnapshotData<D extends FirestoreDocument<any>>(document: D): Promise<Maybe<DocumentDataWithIdAndKey<FirestoreDocumentData<D>>>>;

package/src/lib/common/firestore/collection/collection.d.ts

@@ -317,8 +317,13 @@ export declare function firestoreModelKeyPath(...parts: FirestoreModelKeyPart[])
 export declare function childFirestoreModelKeyPath(parent: FirestoreModelKeyPart, children: ArrayOrValue<FirestoreModelKeyPart>): FirestoreModelKey[];
 export type FirestoreModelCollectionAndIdPairObject = Record<FirestoreCollectionName, FirestoreModelId>;
 export declare function firestoreModelKeyPairObject(input: FirestoreModelKey | DocumentReferenceRef<unknown> | FirestoreModelKeyRef): Maybe<FirestoreModelCollectionAndIdPairObject>;
+/**
+ * String that is composed of the FirestoreCollectionNames derived from an input FirestoreModelKey and joined together via a separator.
+ *
+ * Is equivalent to a FirestoreCollectionType if the FIRESTORE_COLLECTION_NAME_SEPARATOR is used as the separator.
+ */
 export type FirestoreModelCollectionTypeArrayName = string;
-export declare function firestoreModelKeyCollectionType<T = unknown>(input: ReadFirestoreModelKeyInput<T>): Maybe<string>;
+export declare function firestoreModelKeyCollectionType<T = unknown>(input: ReadFirestoreModelKeyInput<T>): Maybe<FirestoreCollectionType>;
 export declare function firestoreModelKeyCollectionTypeArrayName<T = unknown>(input: ReadFirestoreModelKeyInput<T>, separator?: string): Maybe<FirestoreModelCollectionTypeArrayName>;
 export declare function firestoreIdentityTypeArrayName(input: FirestoreModelIdentity, separator?: string): FirestoreModelCollectionTypeArrayName;
 export type FirestoreModelCollectionTypeArray = FirestoreCollectionName[];

package/src/lib/model/index.d.ts

@@ -1,2 +1,3 @@
 export * from './user';
+export * from './notification';
 export * from './system';

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

@@ -0,0 +1,14 @@
+export * from './notification';
+export * from './notification.api';
+export * from './notification.api.error';
+export * from './notification.api.util';
+export * from './notification.action';
+export * from './notification.config';
+export * from './notification.create';
+export * from './notification.details';
+export * from './notification.item';
+export * from './notification.id';
+export * from './notification.message';
+export * from './notification.query';
+export * from './notification.send';
+export * from './notification.util';

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

@@ -0,0 +1,24 @@
+import { type AsyncFirebaseFunctionCreateAction, type AsyncFirebaseFunctionDeleteAction, type AsyncFirebaseFunctionUpdateAction, type FirebaseFunctionCreateAction, type FirebaseFunctionDeleteAction, type FirebaseFunctionUpdateAction } from '../../common';
+import { type NotificationSummaryDocument, type NotificationBoxDocument, type NotificationDocument, type NotificationWeekDocument, type NotificationUserDocument } from './notification';
+export type NotificationUserCreateAction<P extends object> = FirebaseFunctionCreateAction<P, NotificationUserDocument>;
+export type AsyncNotificationUserCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, NotificationUserDocument>;
+export type NotificationUserUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, NotificationUserDocument>;
+export type AsyncNotificationUserUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, NotificationUserDocument>;
+export type NotificationSummaryCreateAction<P extends object> = FirebaseFunctionCreateAction<P, NotificationSummaryDocument>;
+export type AsyncNotificationSummaryCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, NotificationSummaryDocument>;
+export type NotificationSummaryUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, NotificationSummaryDocument>;
+export type AsyncNotificationSummaryUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, NotificationSummaryDocument>;
+export type NotificationBoxCreateAction<P extends object> = FirebaseFunctionCreateAction<P, NotificationBoxDocument>;
+export type AsyncNotificationBoxCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, NotificationBoxDocument>;
+export type NotificationBoxUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, NotificationBoxDocument>;
+export type AsyncNotificationBoxUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, NotificationBoxDocument>;
+export type NotificationCreateAction<P extends object> = FirebaseFunctionCreateAction<P, NotificationDocument, NotificationBoxDocument>;
+export type AsyncNotificationCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, NotificationDocument, NotificationBoxDocument>;
+export type NotificationUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, NotificationDocument>;
+export type AsyncNotificationUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, NotificationDocument>;
+export type NotificationDeleteAction<P extends object> = FirebaseFunctionDeleteAction<P, NotificationDocument>;
+export type AsyncNotificationDeleteAction<P extends object> = AsyncFirebaseFunctionDeleteAction<P, NotificationDocument>;
+export type NotificationWeekCreateAction<P extends object> = FirebaseFunctionCreateAction<P, NotificationWeekDocument>;
+export type AsyncNotificationWeekCreateAction<P extends object> = AsyncFirebaseFunctionCreateAction<P, NotificationWeekDocument>;
+export type NotificationWeekUpdateAction<P extends object> = FirebaseFunctionUpdateAction<P, NotificationWeekDocument>;
+export type AsyncNotificationWeekUpdateAction<P extends object> = AsyncFirebaseFunctionUpdateAction<P, NotificationWeekDocument>;

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

@@ -0,0 +1,389 @@
+import { TargetModelParams, type FirestoreModelKey, type FirebaseAuthUserId } from '../../common';
+import { type ModelFirebaseCrudFunction, type FirebaseFunctionTypeConfigMap, type ModelFirebaseCrudFunctionConfigMap, type ModelFirebaseFunctionMap } from '../../client';
+import { type E164PhoneNumber, type EmailAddress, type IndexNumber, type Maybe } from '@dereekb/util';
+import { type NotificationTypes } from './notification';
+import { type NotificationUserDefaultNotificationBoxRecipientConfig, type NotificationBoxRecipientTemplateConfigArrayEntry, NotificationBoxRecipientFlag } from './notification.config';
+import { type NotificationBoxId, type NotificationSummaryId, type NotificationTemplateType } from './notification.id';
+import { type NotificationSendEmailMessagesResult, type NotificationSendTextMessagesResult, type NotificationSendNotificationSummaryMessagesResult } from './notification.send';
+export declare const NOTIFICATION_RECIPIENT_NAME_MIN_LENGTH = 0;
+export declare const NOTIFICATION_RECIPIENT_NAME_MAX_LENGTH = 42;
+export declare const NOTIFICATION_SUBJECT_MIN_LENGTH = 2;
+export declare const NOTIFICATION_SUBJECT_MAX_LENGTH = 100;
+export declare const NOTIFICATION_MESSAGE_MIN_LENGTH = 2;
+export declare const NOTIFICATION_MESSAGE_MAX_LENGTH = 1000;
+/**
+ * Config entries are inserted, unless marked as remove.
+ */
+export declare class NotificationBoxRecipientTemplateConfigArrayEntryParam implements NotificationBoxRecipientTemplateConfigArrayEntry {
+    type: string;
+    sd?: Maybe<boolean>;
+    se?: Maybe<boolean>;
+    st?: Maybe<boolean>;
+    sp?: Maybe<boolean>;
+    sn?: Maybe<boolean>;
+    /**
+     * If true, removes this configuration
+     */
+    remove?: Maybe<boolean>;
+}
+/**
+ * Used for creating a new NotificationUser for a user.
+ */
+export declare class CreateNotificationUserParams {
+    /**
+     * UID of the user to create the NotificationUser for.
+     */
+    uid: FirebaseAuthUserId;
+}
+/**
+ * Used for updating the global or default config on a NotificationUser.
+ */
+export declare class UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams implements Omit<NotificationUserDefaultNotificationBoxRecipientConfig, 'c'> {
+    /**
+     * NotificationBox recipient to update. Is ignored if UID is provided and matches a user. Used for external recipients/users.
+     */
+    i?: Maybe<IndexNumber>;
+    /**
+     * Override email address
+     */
+    e?: Maybe<EmailAddress>;
+    /**
+     * Override phone number
+     */
+    t?: Maybe<E164PhoneNumber>;
+    /**
+     * Array of configs that correspond with "c"
+     */
+    configs?: Maybe<NotificationBoxRecipientTemplateConfigArrayEntryParam[]>;
+    lk?: Maybe<boolean>;
+    bk?: Maybe<boolean>;
+    f?: Maybe<NotificationBoxRecipientFlag>;
+}
+export declare class UpdateNotificationBoxRecipientLikeParams {
+    /**
+     * Override email address
+     */
+    e?: Maybe<EmailAddress>;
+    /**
+     * Override phone number
+     */
+    t?: Maybe<E164PhoneNumber>;
+    /**
+     * Notification summary id
+     */
+    s?: Maybe<NotificationSummaryId>;
+    /**
+     * Array of configs
+     */
+    configs?: Maybe<NotificationBoxRecipientTemplateConfigArrayEntryParam[]>;
+}
+/**
+ * Used for updating the target NotificationUserNotificationBoxRecipientConfig.
+ */
+export declare class UpdateNotificationUserNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams {
+    /**
+     * NotificationBox config to update
+     */
+    nb: NotificationBoxId;
+    rm?: Maybe<boolean>;
+    lk?: Maybe<boolean>;
+    bk?: Maybe<boolean>;
+    f?: Maybe<NotificationBoxRecipientFlag>;
+    /**
+     * Whether or not to delete this configuration entirely.
+     *
+     * Will only delete if rm is true and ns is false. Is ignored otherwise.
+     */
+    deleteRemovedConfig?: Maybe<boolean>;
+}
+/**
+ * Used for updating the NotificationUser.
+ */
+export declare class UpdateNotificationUserParams extends TargetModelParams {
+    gc?: Maybe<UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams>;
+    dc?: Maybe<UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams>;
+    bc?: Maybe<UpdateNotificationUserNotificationBoxRecipientParams[]>;
+}
+export declare class ResyncNotificationUserParams extends TargetModelParams {
+}
+export interface ResyncNotificationUserResult {
+    /**
+     * Total number of notification boxes updated.
+     */
+    readonly notificationBoxesUpdated: number;
+}
+export declare class ResyncAllNotificationUserParams {
+}
+export interface ResyncAllNotificationUsersResult extends ResyncNotificationUserResult {
+    /**
+     * Total number of users updated.
+     */
+    readonly notificationUsersResynced: number;
+}
+/**
+ * Used for creating a new NotificationSummary for a model.
+ */
+export declare class CreateNotificationSummaryParams {
+    /**
+     * Model to create the NotificationSummary for.
+     */
+    model: FirestoreModelKey;
+}
+/**
+ * Used for updating the NotificationSummary.
+ */
+export declare class UpdateNotificationSummaryParams extends TargetModelParams {
+    /**
+     * Updates the "rat" time to now.
+     */
+    readonly flagAllRead?: Maybe<boolean>;
+    /**
+     * Sets the "rat" time to the given date, or clears it.
+     */
+    readonly setReadAtTime?: Maybe<Date>;
+}
+/**
+ * Used for creating or initializing a new NotificationBox for a model.
+ *
+ * Mainly used for testing. Not exposed to the API.
+ *
+ * The preferred way is to create a NotificationBox through a Notification.
+ */
+export declare class CreateNotificationBoxParams {
+    model: FirestoreModelKey;
+}
+/**
+ * Used for initializing an uninitialized model like NotificationBox or NotificationSummary.
+ */
+export declare class InitializeNotificationModelParams extends TargetModelParams {
+    /**
+     * Whether or not to throw an error if the notification has already been sent or is being sent.
+     */
+    throwErrorIfAlreadyInitialized?: boolean;
+}
+export declare class InitializeAllApplicableNotificationBoxesParams {
+}
+export interface InitializeAllApplicableNotificationBoxesResult {
+    readonly notificationBoxesVisited: number;
+    readonly notificationBoxesSucceeded: number;
+    readonly notificationBoxesFailed: number;
+    readonly notificationBoxesAlreadyInitialized: number;
+}
+export declare class InitializeAllApplicableNotificationSummariesParams {
+}
+export interface InitializeAllApplicableNotificationSummariesResult {
+    readonly notificationSummariesVisited: number;
+    readonly notificationSummariesSucceeded: number;
+    readonly notificationSummariesFailed: number;
+    readonly notificationSummariesAlreadyInitialized: number;
+}
+/**
+ * Used for updating the NotificationBox.
+ */
+export declare class UpdateNotificationBoxParams extends TargetModelParams {
+}
+/**
+ * Used to create/update a notification box recipient.
+ */
+export declare class UpdateNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams implements TargetModelParams {
+    /**
+     * NotificationBox key to update.
+     */
+    key: FirestoreModelKey;
+    /**
+     * NotificationBox recipient to update. Is ignored if UID is provided and matches a user. Used for external recipients/users.
+     */
+    i?: Maybe<IndexNumber>;
+    /**
+     * Notification recipient to update by UID, if applicable.
+     */
+    uid?: Maybe<FirebaseAuthUserId>;
+    /**
+     * Whether or not to insert the user if they currently do not exist. Defaults to false.
+     */
+    insert?: Maybe<boolean>;
+    /**
+     * Whether or not to enable/disable the recipient from recieving items from this box.
+     */
+    enabled?: Maybe<boolean>;
+    /**
+     * Whether or not to remove the user if they exist. Defaults to false.
+     */
+    remove?: Maybe<boolean>;
+}
+export declare class NotificationRecipientParams {
+    /**
+     * User to send the notification to.
+     */
+    uid?: Maybe<FirebaseAuthUserId>;
+    /**
+     * Recipient Name
+     */
+    un?: Maybe<string>;
+    /**
+     * Email address
+     */
+    e?: Maybe<EmailAddress>;
+    /**
+     * Phone number
+     */
+    p?: Maybe<E164PhoneNumber>;
+}
+/**
+ * Used for sending the notification immediately, if it has not already been sent.
+ */
+export declare class SendNotificationParams extends TargetModelParams {
+    /**
+     * Whether or not to ignore the send at time. Defaults to false.
+     */
+    ignoreSendAtThrottle?: Maybe<boolean>;
+    /**
+     * Whether or not to throw an error if the notification has already been sent or is being sent.
+     */
+    throwErrorIfSent?: Maybe<boolean>;
+}
+export interface SendNotificationResult {
+    /**
+     * Attempted notification type
+     */
+    readonly notificationTemplateType: Maybe<NotificationTemplateType>;
+    /**
+     * Whether or not the notification was of a known type.
+     */
+    readonly isKnownTemplateType: Maybe<boolean>;
+    /**
+     * Whether or not the notification was of a configured type.
+     */
+    readonly isConfiguredTemplateType: Maybe<boolean>;
+    /**
+     * Whether or not the try was aborted due to being throttled.
+     */
+    readonly throttled: boolean;
+    /**
+     * Whether or not the run was successful.
+     *
+     * In cases where the Notification is set to SEND_IF_BOX_EXISTS and the box does not exist, this will return true.
+     */
+    readonly success: boolean;
+    /**
+     * Whether or not the notification was marked as done.
+     *
+     * May occur in cases where success is false, but the notification reached the max number of send attempts.
+     */
+    readonly notificationMarkedDone: boolean;
+    /**
+     * Whether or not the NotificationBox was created.
+     */
+    readonly createdBox: boolean;
+    /**
+     * Whether or not the NotificationBox exists but still needs initialization.
+     */
+    readonly notificationBoxNeedsInitialization: boolean;
+    /**
+     * Whether or not the notification was deleted.
+     *
+     * This typically only occurs when SEND_IF_BOX_EXISTS is set and the box does not exist.
+     */
+    readonly deletedNotification: boolean;
+    readonly exists: boolean;
+    readonly boxExists: boolean;
+    readonly tryRun: boolean;
+    /**
+     * Send emails result.
+     *
+     * Undefined if not attempted.
+     */
+    readonly sendEmailsResult: Maybe<NotificationSendEmailMessagesResult>;
+    /**
+     *
+     * Send texts result.
+     *
+     * Undefined if not attempted.
+     */
+    readonly sendTextsResult: Maybe<NotificationSendTextMessagesResult>;
+    /**
+     * Send notification summaries result.
+     *
+     * Undefined if not attempted.
+     */
+    readonly sendNotificationSummaryResult: Maybe<NotificationSendNotificationSummaryMessagesResult>;
+    /**
+     * Failed while attempting to loada the proper message function
+     */
+    readonly loadMessageFunctionFailure: boolean;
+    /**
+     * Failed while attempting to build a message
+     */
+    readonly buildMessageFailure: boolean;
+}
+/**
+ * Used for sending queued notifications in the system.
+ */
+export declare class SendQueuedNotificationsParams {
+}
+export interface SendQueuedNotificationsResult extends Omit<SendNotificationResult, 'throttled' | 'isConfiguredTemplateType' | 'isKnownTemplateType' | 'notificationTemplateType' | 'notificationMarkedDone' | 'deletedNotification' | 'createdBox' | 'success' | 'exists' | 'boxExists' | 'notificationBoxNeedsInitialization' | 'tryRun' | 'loadMessageFunctionFailure' | 'buildMessageFailure'> {
+    readonly notificationBoxesCreated: number;
+    readonly notificationsVisited: number;
+    readonly notificationsSucceeded: number;
+    readonly notificationsDelayed: number;
+    readonly notificationsFailed: number;
+    readonly notificationsDeleted: number;
+}
+/**
+ * Used for sending queued notifications in the system.
+ */
+export declare class CleanupSentNotificationsParams {
+}
+export interface CleanupSentNotificationsResult {
+    /**
+     * Number of total updates. May include the same notification box more than once.
+     */
+    readonly notificationBoxesUpdatesCount: number;
+    readonly notificationsDeleted: number;
+    readonly notificationWeeksCreated: number;
+    readonly notificationWeeksUpdated: number;
+}
+export type NotificationFunctionTypeMap = {};
+export declare const notificationFunctionTypeConfigMap: FirebaseFunctionTypeConfigMap<NotificationFunctionTypeMap>;
+export type NotificationBoxModelCrudFunctionsConfig = {
+    readonly notificationUser: {
+        update: {
+            _: UpdateNotificationUserParams;
+            resync: [ResyncNotificationUserParams, ResyncNotificationUserResult];
+        };
+    };
+    readonly notificationSummary: {
+        update: {
+            _: UpdateNotificationSummaryParams;
+        };
+    };
+    readonly notificationBox: {
+        update: {
+            _: UpdateNotificationBoxParams;
+            recipient: UpdateNotificationBoxRecipientParams;
+        };
+    };
+    readonly notification: null;
+    readonly notificationWeek: null;
+};
+export declare const notificationBoxModelCrudFunctionsConfig: ModelFirebaseCrudFunctionConfigMap<NotificationBoxModelCrudFunctionsConfig, NotificationTypes>;
+export declare abstract class NotificationFunctions implements ModelFirebaseFunctionMap<NotificationFunctionTypeMap, NotificationBoxModelCrudFunctionsConfig> {
+    abstract notificationUser: {
+        updateNotificationUser: {
+            update: ModelFirebaseCrudFunction<UpdateNotificationUserParams>;
+            resync: ModelFirebaseCrudFunction<ResyncNotificationUserParams, ResyncNotificationUserResult>;
+        };
+    };
+    abstract notificationSummary: {
+        updateNotificationSummary: {
+            update: ModelFirebaseCrudFunction<UpdateNotificationSummaryParams>;
+        };
+    };
+    abstract notificationBox: {
+        updateNotificationBox: {
+            update: ModelFirebaseCrudFunction<UpdateNotificationBoxParams>;
+            recipient: ModelFirebaseCrudFunction<UpdateNotificationBoxRecipientParams>;
+        };
+    };
+}
+export declare const notificationFunctionMap: import("../../client").ModelFirebaseFunctionMapFactory<NotificationFunctionTypeMap, NotificationBoxModelCrudFunctionsConfig>;

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

@@ -0,0 +1,7 @@
+export declare const CREATE_NOTIFICATION_ID_REQUIRED_ERROR_CODE = "CREATE_NOTIFICATION_ID_REQUIRED";
+export declare const NOTIFICATION_MODEL_ALREADY_INITIALIZED_ERROR_CODE = "NOTIFICATION_MODEL_ALREADY_INITIALIZED";
+export declare const NOTIFICATION_BOX_EXISTS_FOR_MODEL_ERROR_CODE = "NOTIFICATION_BOX_EXISTS_FOR_MODEL";
+export declare const NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST_ERROR_CODE = "NOTIFICATION_BOX_RECIPIENT_DOES_NOT_EXIST";
+export declare const NOTIFICATION_USER_INVALID_UID_FOR_CREATE_ERROR_CODE = "NOTIFICATION_USER_INVALID_UID_FOR_CREATE";
+export declare const NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS_ERROR_CODE = "NOTIFICATION_USER_BLOCKED_FROM_BEING_ADD_TO_RECIPIENTS";
+export declare const NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED_ERROR_CODE = "NOTIFICATION_USER_LOCKED_CONFIG_FROM_BEING_UPDATED";

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

@@ -0,0 +1,31 @@
+import { type Maybe } from '@dereekb/util';
+import { type NotificationBoxRecipientTemplateConfigRecord, type NotificationUserDefaultNotificationBoxRecipientConfig, type NotificationUserNotificationBoxRecipientConfig } from './notification.config';
+import { type NotificationBoxRecipientTemplateConfigArrayEntryParam, type UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams, type UpdateNotificationUserNotificationBoxRecipientParams } from './notification.api';
+import { type AppNotificationTemplateTypeInfoRecordService } from './notification.details';
+import { type NotificationTemplateType } from './notification.id';
+/**
+ * Updates a NotificationUserDefaultNotificationBoxRecipientConfig with the input UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function updateNotificationBoxRecipientTemplateConfigRecord(a: NotificationBoxRecipientTemplateConfigRecord, b: NotificationBoxRecipientTemplateConfigArrayEntryParam[], limitToAllowedConfigTypes?: Maybe<Iterable<NotificationTemplateType>>): NotificationBoxRecipientTemplateConfigRecord | undefined;
+/**
+ * Updates a NotificationUserDefaultNotificationBoxRecipientConfig with the input UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function updateNotificationUserDefaultNotificationBoxRecipientConfig(a: NotificationUserDefaultNotificationBoxRecipientConfig, b: UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams, limitToAllowedConfigTypes?: Maybe<Iterable<NotificationTemplateType>>): NotificationUserDefaultNotificationBoxRecipientConfig;
+export declare function updateNotificationUserNotificationBoxRecipientConfigIfChanged(a: NotificationUserNotificationBoxRecipientConfig, b: UpdateNotificationUserNotificationBoxRecipientParams, limitToAllowedConfigTypes?: Maybe<Iterable<NotificationTemplateType>>): NotificationUserNotificationBoxRecipientConfig | undefined;
+/**
+ * Updates the target NotificationUserNotificationBoxRecipientConfig array with the input UpdateNotificationUserNotificationBoxRecipientParams.
+ *
+ * If the target NotificationBox does not exist in the config, it is ignored.
+ *
+ * @param a
+ * @param b
+ */
+export declare function updateNotificationUserNotificationBoxRecipientConfigs(a: NotificationUserNotificationBoxRecipientConfig[], b: UpdateNotificationUserNotificationBoxRecipientParams[], filterWithService?: AppNotificationTemplateTypeInfoRecordService): NotificationUserNotificationBoxRecipientConfig[] | undefined;