/**
 * @module notification.api
 *
 * API parameter types, Arktype validation schemas, and Firebase function definitions for the notification CRUD operations.
 *
 * Each param interface has a corresponding Arktype validator (e.g., {@link updateNotificationUserParamsType}).
 * The {@link NotificationFunctions} abstract class defines the client-callable function map.
 */
import { type Type } from 'arktype';
import { type 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';
import { type NotificationTaskServiceTaskHandlerCompletionType } from './notification.task';
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 interface NotificationBoxRecipientTemplateConfigArrayEntryParam extends NotificationBoxRecipientTemplateConfigArrayEntry {
    readonly type: NotificationTemplateType;
    readonly sd?: Maybe<boolean>;
    readonly se?: Maybe<boolean>;
    readonly st?: Maybe<boolean>;
    readonly sp?: Maybe<boolean>;
    readonly sn?: Maybe<boolean>;
    readonly remove?: Maybe<boolean>;
}
export declare const notificationBoxRecipientTemplateConfigArrayEntryParamType: import("arktype/internal/variants/object.ts").ObjectType<{
    type: string;
    sd?: boolean | null | undefined;
    se?: boolean | null | undefined;
    st?: boolean | null | undefined;
    sp?: boolean | null | undefined;
    sn?: boolean | null | undefined;
    remove?: boolean | null | undefined;
}, {}>;
/**
 * Used for creating a new NotificationUser for a user.
 */
export interface CreateNotificationUserParams {
    readonly uid: FirebaseAuthUserId;
}
export declare const createNotificationUserParamsType: Type<CreateNotificationUserParams>;
/**
 * Used for updating the global or default config on a NotificationUser.
 */
export interface UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams extends Omit<NotificationUserDefaultNotificationBoxRecipientConfig, 'c'> {
    readonly i?: Maybe<IndexNumber>;
    readonly e?: Maybe<EmailAddress>;
    readonly t?: Maybe<E164PhoneNumber>;
    readonly configs?: Maybe<NotificationBoxRecipientTemplateConfigArrayEntryParam[]>;
    readonly lk?: Maybe<boolean>;
    readonly bk?: Maybe<boolean>;
    readonly f?: Maybe<NotificationBoxRecipientFlag>;
}
export declare const updateNotificationUserDefaultNotificationBoxRecipientConfigParamsType: Type<UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams>;
export interface UpdateNotificationBoxRecipientLikeParams {
    readonly e?: Maybe<EmailAddress>;
    readonly t?: Maybe<E164PhoneNumber>;
    readonly s?: Maybe<NotificationSummaryId>;
    readonly configs?: Maybe<NotificationBoxRecipientTemplateConfigArrayEntryParam[]>;
}
export declare const updateNotificationBoxRecipientLikeParamsType: Type<UpdateNotificationBoxRecipientLikeParams>;
/**
 * Used for updating the target NotificationUserNotificationBoxRecipientConfig.
 */
export interface UpdateNotificationUserNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams {
    readonly nb: NotificationBoxId;
    readonly rm?: Maybe<boolean>;
    readonly lk?: Maybe<boolean>;
    readonly bk?: Maybe<boolean>;
    readonly f?: Maybe<NotificationBoxRecipientFlag>;
    readonly deleteRemovedConfig?: Maybe<boolean>;
}
export declare const updateNotificationUserNotificationBoxRecipientParamsType: Type<UpdateNotificationUserNotificationBoxRecipientParams>;
/**
 * Used for updating the NotificationUser.
 */
export interface UpdateNotificationUserParams extends TargetModelParams {
    readonly gc?: Maybe<UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams>;
    readonly dc?: Maybe<UpdateNotificationUserDefaultNotificationBoxRecipientConfigParams>;
    readonly bc?: Maybe<UpdateNotificationUserNotificationBoxRecipientParams[]>;
}
export declare const updateNotificationUserParamsType: Type<UpdateNotificationUserParams>;
export type ResyncNotificationUserParams = TargetModelParams;
export declare const resyncNotificationUserParamsType: import("arktype/internal/variants/object.ts").ObjectType<TargetModelParams, {}>;
export interface ResyncNotificationUserResult {
    readonly notificationBoxesUpdated: number;
}
export interface ResyncAllNotificationUserParams {
}
export declare const resyncAllNotificationUserParamsType: Type<ResyncAllNotificationUserParams>;
export interface ResyncAllNotificationUsersResult extends ResyncNotificationUserResult {
    readonly notificationUsersResynced: number;
}
/**
 * Used for creating a new NotificationSummary for a model.
 */
export interface CreateNotificationSummaryParams {
    readonly model: FirestoreModelKey;
}
export declare const createNotificationSummaryParamsType: Type<CreateNotificationSummaryParams>;
/**
 * Used for updating the NotificationSummary.
 */
export interface UpdateNotificationSummaryParams extends TargetModelParams {
    readonly flagAllRead?: Maybe<boolean>;
    readonly setReadAtTime?: Maybe<Date>;
}
export declare const updateNotificationSummaryParamsType: Type<UpdateNotificationSummaryParams>;
/**
 * 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 interface CreateNotificationBoxParams {
    readonly model: FirestoreModelKey;
}
export declare const createNotificationBoxParamsType: Type<CreateNotificationBoxParams>;
/**
 * Used for initializing an uninitialized model like NotificationBox or NotificationSummary.
 */
export interface InitializeNotificationModelParams extends TargetModelParams {
    readonly throwErrorIfAlreadyInitialized?: boolean;
}
export declare const initializeNotificationModelParamsType: Type<InitializeNotificationModelParams>;
export interface InitializeAllApplicableNotificationBoxesParams {
}
export declare const initializeAllApplicableNotificationBoxesParamsType: Type<InitializeAllApplicableNotificationBoxesParams>;
export interface InitializeAllApplicableNotificationBoxesResult {
    readonly notificationBoxesVisited: number;
    readonly notificationBoxesSucceeded: number;
    readonly notificationBoxesFailed: number;
    readonly notificationBoxesAlreadyInitialized: number;
}
export interface InitializeAllApplicableNotificationSummariesParams {
}
export declare const initializeAllApplicableNotificationSummariesParamsType: Type<InitializeAllApplicableNotificationSummariesParams>;
export interface InitializeAllApplicableNotificationSummariesResult {
    readonly notificationSummariesVisited: number;
    readonly notificationSummariesSucceeded: number;
    readonly notificationSummariesFailed: number;
    readonly notificationSummariesAlreadyInitialized: number;
}
/**
 * Used for updating the NotificationBox.
 */
export type UpdateNotificationBoxParams = TargetModelParams;
export declare const updateNotificationBoxParamsType: import("arktype/internal/variants/object.ts").ObjectType<TargetModelParams, {}>;
/**
 * Used to create/update a notification box recipient.
 */
export interface UpdateNotificationBoxRecipientParams extends UpdateNotificationBoxRecipientLikeParams, TargetModelParams {
    readonly key: FirestoreModelKey;
    readonly i?: Maybe<IndexNumber>;
    readonly uid?: Maybe<FirebaseAuthUserId>;
    readonly insert?: Maybe<boolean>;
    readonly enabled?: Maybe<boolean>;
    readonly remove?: Maybe<boolean>;
    readonly setExclusion?: Maybe<boolean>;
}
export declare const updateNotificationBoxRecipientParamsType: Type<UpdateNotificationBoxRecipientParams>;
export interface NotificationRecipientParams {
    readonly uid?: Maybe<FirebaseAuthUserId>;
    readonly un?: Maybe<string>;
    readonly e?: Maybe<EmailAddress>;
    readonly p?: Maybe<E164PhoneNumber>;
}
export declare const notificationRecipientParamsType: Type<NotificationRecipientParams>;
/**
 * Used for sending the notification immediately, if it has not already been sent.
 */
export interface SendNotificationParams extends TargetModelParams {
    readonly ignoreSendAtThrottle?: Maybe<boolean>;
    readonly throwErrorIfSent?: Maybe<boolean>;
}
export declare const sendNotificationParamsType: Type<SendNotificationParams>;
/**
 * Params class used for subscribing a system user to a NotificationBox for a model.
 */
export interface AbstractSubscribeToNotificationBoxParams extends TargetModelParams {
    readonly uid: FirebaseAuthUserId;
}
export declare const abstractSubscribeToNotificationBoxParamsType: Type<AbstractSubscribeToNotificationBoxParams>;
export interface AbstractSubscribeOrUnsubscribeToNotificationBoxParams extends AbstractSubscribeToNotificationBoxParams {
    readonly unsubscribe?: Maybe<boolean>;
}
export declare const abstractSubscribeOrUnsubscribeToNotificationBoxParamsType: Type<AbstractSubscribeOrUnsubscribeToNotificationBoxParams>;
export interface SendNotificationResultOnSendCompleteResult<T = unknown> {
    readonly value?: T;
    readonly error?: Maybe<unknown>;
}
/**
 * Detailed result returned by the `sendNotification` function, describing the outcome of sending a single notification.
 */
export interface SendNotificationResult {
    readonly notificationTemplateType: Maybe<NotificationTemplateType>;
    readonly isKnownTemplateType: Maybe<boolean>;
    readonly isNotificationTask: boolean;
    readonly isUniqueNotificationTask: boolean;
    readonly uniqueNotificationTaskConflict: boolean;
    readonly isConfiguredTemplateType: Maybe<boolean>;
    readonly throttled: boolean;
    readonly success: boolean;
    readonly notificationTaskCompletionType?: Maybe<NotificationTaskServiceTaskHandlerCompletionType>;
    readonly notificationTaskPartsRunCount?: Maybe<number>;
    readonly notificationTaskLoopingProtectionTriggered?: Maybe<boolean>;
    readonly notificationMarkedDone: boolean;
    readonly createdBox: boolean;
    readonly notificationBoxNeedsInitialization: boolean;
    readonly deletedNotification: boolean;
    readonly exists: boolean;
    readonly boxExists: boolean;
    readonly tryRun: boolean;
    readonly sendEmailsResult: Maybe<NotificationSendEmailMessagesResult>;
    readonly sendTextsResult: Maybe<NotificationSendTextMessagesResult>;
    readonly sendNotificationSummaryResult: Maybe<NotificationSendNotificationSummaryMessagesResult>;
    readonly loadMessageFunctionFailure: boolean;
    readonly buildMessageFailure: boolean;
    readonly onSendAttemptedResult?: Maybe<SendNotificationResultOnSendCompleteResult>;
    readonly onSendSuccessResult?: Maybe<SendNotificationResultOnSendCompleteResult>;
}
/**
 * Used for sending queued notifications in the system.
 */
export interface SendQueuedNotificationsParams {
    readonly maxSendNotificationLoops?: Maybe<number>;
    readonly maxParellelSendTasks?: Maybe<number>;
    readonly sendNotificationLoopsTaskExcessThreshold?: Maybe<number>;
}
export declare const sendQueuedNotificationsParamsType: Type<SendQueuedNotificationsParams>;
/**
 * Aggregate result of processing the notification send queue, with counts of visited, succeeded, failed, and deleted notifications.
 */
export interface SendQueuedNotificationsResult extends Omit<SendNotificationResult, 'throttled' | 'isNotificationTask' | 'isUniqueNotificationTask' | 'notificationTaskCompletionType' | 'uniqueNotificationTaskConflict' | 'isConfiguredTemplateType' | 'isKnownTemplateType' | 'notificationTemplateType' | 'notificationMarkedDone' | 'deletedNotification' | 'createdBox' | 'success' | 'exists' | 'boxExists' | 'notificationBoxNeedsInitialization' | 'tryRun' | 'loadMessageFunctionFailure' | 'buildMessageFailure'> {
    readonly excessLoopsDetected: boolean;
    readonly notificationLoopCount: number;
    readonly notificationBoxesCreated: number;
    readonly notificationsVisited: number;
    readonly notificationTasksVisited: number;
    readonly notificationsSucceeded: number;
    readonly notificationsDelayed: number;
    readonly notificationsFailed: number;
    readonly notificationsDeleted: number;
}
/**
 * Used for sending queued notifications in the system.
 */
export interface CleanupSentNotificationsParams {
}
export declare const cleanupSentNotificationsParamsType: Type<CleanupSentNotificationsParams>;
export interface CleanupSentNotificationsResult {
    readonly notificationBoxesUpdatesCount: number;
    readonly notificationTasksDeletedCount: number;
    readonly notificationsDeleted: number;
    readonly notificationWeeksCreated: number;
    readonly notificationWeeksUpdated: number;
}
/**
 * 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 type NotificationBoxModelCrudFunctionsConfig = {
    readonly notificationUser: {
        update: {
            _: UpdateNotificationUserParams;
            resync: [ResyncNotificationUserParams, ResyncNotificationUserResult];
        };
    };
    readonly notificationSummary: {
        update: {
            _: UpdateNotificationSummaryParams;
        };
    };
    readonly notificationBox: {
        update: {
            _: UpdateNotificationBoxParams;
            recipient: UpdateNotificationBoxRecipientParams;
        };
    };
    readonly notification: {
        update: {
            send: [SendNotificationParams, SendNotificationResult];
        };
    };
    readonly notificationWeek: null;
};
export declare const notificationBoxModelCrudFunctionsConfig: ModelFirebaseCrudFunctionConfigMap<NotificationBoxModelCrudFunctionsConfig, NotificationTypes>;
/**
 * Abstract client-callable function map for notification CRUD operations.
 *
 * Implementations are generated by {@link notificationFunctionMap} for client-side use,
 * and by the server-side function registration in the demo-api or application module.
 */
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>;
        };
    };
    abstract notification: {
        updateNotification: {
            send: ModelFirebaseCrudFunction<SendNotificationParams, SendNotificationResult>;
        };
    };
}
/**
 * Factory for creating client-side callable function instances from the notification CRUD configuration.
 */
export declare const notificationFunctionMap: import("../..").ModelFirebaseFunctionMapFactory<NotificationFunctionTypeMap, NotificationBoxModelCrudFunctionsConfig>;