@dereekb/firebase 13.41.0 → 13.43.0

package/src/lib/model/formspace/formspace.util.d.ts

@@ -0,0 +1,348 @@
+import { type ContentTypeMimeType, type Maybe } from '@dereekb/util';
+import { type FirebaseAuthOwnershipKey, type FirebaseAuthUserId } from '../../common/auth/auth';
+import { type FirestoreModelKey } from '../../common/firestore/collection/collection';
+import { type StorageFileGroupId } from '../storagefile/storagefile.id';
+import { type FormSpace, type FormSpaceData, type FormSpaceFile } from './formspace';
+import { type FormSpaceFileSlot, type FormSpaceKey, type FormSpaceType } from './formspace.id';
+import { type FormSpaceFileSlotConfig, type FormSpaceTypeConfig } from './formspace.type';
+/**
+ * @module formspace.util
+ *
+ * Pure helpers shared by the client and the server: the write templates for each lifecycle transition, and
+ * the upload predicate.
+ *
+ * {@link assertFormSpaceUploadAllowed} in particular is deliberately PURE and lives here rather than in
+ * `firebase-server`: the client pre-checks a file with it before asking for a signed URL, and the server's
+ * upload initializer enforces the very same function afterwards. One rule, two callers — a client-side copy
+ * that drifted would show the user an accept for a file the server then silently discards.
+ *
+ * A file's NAME is not one of the rules. It used to be: two files of one name in a slot resolved to the
+ * same destination object, so the second silently overwrote the first. The destination is now keyed by the
+ * space's `fi` index instead, so two files of one name are two objects, and the name is free to be
+ * whatever the user uploaded.
+ */
+/**
+ * Returns the {@link StorageFileGroupId} that owns every file uploaded into a FormSpace.
+ *
+ * The group is keyed by the FormSpace's own model key, so the existing sync machinery creates it on the
+ * first upload and the existing zip / cleanup machinery applies with no FormSpace-specific code.
+ *
+ * @param formSpaceKey - The FormSpace's model key.
+ * @returns The group id.
+ *
+ * @example
+ * ```ts
+ * const groupId = formSpaceStorageFileGroupId('fsp/abc123'); // 'fsp_abc123'
+ * ```
+ */
+export declare function formSpaceStorageFileGroupId(formSpaceKey: FormSpaceKey): StorageFileGroupId;
+/**
+ * Input for {@link resolveFormSpaceExpiresAt}.
+ */
+export interface ResolveFormSpaceExpiresAtInput {
+    readonly config: FormSpaceTypeConfig;
+    /**
+     * The instant the space is being created at. Defaults to now.
+     */
+    readonly now?: Maybe<Date>;
+}
+/**
+ * Returns the instant a newly created FormSpace of the given type expires at, or null when its type never
+ * expires.
+ *
+ * Null is meaningful rather than merely absent: it is what leaves `eat` unwritten, and an unwritten `eat`
+ * is what excludes the space from the sweep's inequality query.
+ *
+ * @param input - The type config and creation instant.
+ * @returns The expiration instant, or null when the type does not expire.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function resolveFormSpaceExpiresAt(input: ResolveFormSpaceExpiresAtInput): Maybe<Date>;
+/**
+ * Input for {@link formSpaceTemplate}.
+ */
+export interface FormSpaceTemplateInput<T extends FormSpaceData = FormSpaceData> {
+    readonly formSpaceType: FormSpaceType;
+    readonly uid: FirebaseAuthUserId;
+    readonly ownerKey?: Maybe<FirebaseAuthOwnershipKey>;
+    readonly targetModelKey?: Maybe<FirestoreModelKey>;
+    readonly displayName?: Maybe<string>;
+    readonly data?: Maybe<T>;
+    readonly expiresAt?: Maybe<Date>;
+    /**
+     * The creation instant. Defaults to now.
+     */
+    readonly now?: Maybe<Date>;
+}
+/**
+ * Builds the complete document template for a newly created FormSpace.
+ *
+ * @param input - The type, owner, and initial content of the space.
+ * @returns The FormSpace template.
+ *
+ * @example
+ * ```ts
+ * const template = formSpaceTemplate({ formSpaceType: 'demo_example', uid: 'user123' });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceTemplate<T extends FormSpaceData = FormSpaceData>(input: FormSpaceTemplateInput<T>): FormSpace<T>;
+/**
+ * Builds the update template that submits a FormSpace.
+ *
+ * Clearing `eat` is not tidiness: a submitted space that kept its expiration instant would still match the
+ * expiration sweep and be retired out from under the processing task.
+ *
+ * @param now - The submission instant. Defaults to now.
+ * @returns The update template.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function submitFormSpaceTemplate(now?: Maybe<Date>): Partial<FormSpace>;
+/**
+ * Builds the update template that expires a FormSpace.
+ *
+ * @param now - The expiration instant. Defaults to now.
+ * @returns The update template.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function expireFormSpaceTemplate(now?: Maybe<Date>): Partial<FormSpace>;
+/**
+ * Input for {@link isFormSpaceEditable}.
+ */
+export interface IsFormSpaceEditableInput {
+    readonly formSpace: Pick<FormSpace, 's' | 'sat' | 'eat'>;
+    /**
+     * The instant to judge against. Defaults to now.
+     */
+    readonly now?: Maybe<Date>;
+}
+/**
+ * Returns true when a FormSpace may still be edited or uploaded into.
+ *
+ * Checks the expiration instant as well as the state, so a space whose sweep has not run yet is already
+ * closed. The sweep is what RETIRES the document; it is not what makes it un-editable.
+ *
+ * @param input - The space and the instant to judge against.
+ * @returns True when the space is editable.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function isFormSpaceEditable(input: IsFormSpaceEditableInput): boolean;
+/**
+ * Returns the slot config a type declares for the given slot, or null when it declares none.
+ *
+ * @param config - The type config.
+ * @param slot - The slot to look up.
+ * @returns The slot config, or null.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceFileSlotConfig(config: FormSpaceTypeConfig, slot: FormSpaceFileSlot): Maybe<FormSpaceFileSlotConfig>;
+/**
+ * Returns the human-readable name of a slot, falling back to the slot key itself.
+ *
+ * The key is a reasonable fallback rather than a placeholder: a slot is named `resume` or `cover` precisely
+ * because that is what it holds, so a type that declared no `name` still reads as something.
+ *
+ * @param config - The type config.
+ * @param slot - The slot to name.
+ * @returns The slot's name.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceFileSlotName(config: FormSpaceTypeConfig, slot: FormSpaceFileSlot): string;
+/**
+ * Returns how many files a slot may hold at once.
+ *
+ * @param slotConfig - The slot config, or null for an undeclared slot.
+ * @returns The slot's file capacity.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceSlotMaxFiles(slotConfig: Maybe<FormSpaceFileSlotConfig>): number;
+/**
+ * Returns how many files a slot must hold before the space may be submitted.
+ *
+ * `required` is the older, coarser spelling of the same idea, so it resolves to 1 when `minFiles` is absent.
+ *
+ * @param slotConfig - The slot config, or null for an undeclared slot.
+ * @returns The slot's minimum file count.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceSlotMinFiles(slotConfig: Maybe<FormSpaceFileSlotConfig>): number;
+/**
+ * Returns the files a FormSpace currently holds in one slot.
+ *
+ * @param formSpace - The space to read.
+ * @param slot - The slot to filter by.
+ * @returns The slot's files, in the order the space stores them.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceFilesInSlot(formSpace: Pick<FormSpace, 'f'>, slot: FormSpaceFileSlot): FormSpaceFile[];
+/**
+ * Every slot a type requires be filled before its spaces may be submitted.
+ *
+ * A CLIENT-side convenience for labelling a form's required slots. The submit gate itself uses
+ * {@link formSpaceSubmitBlockers}, which also understands `minFiles` and validation state.
+ *
+ * @param config - The type config.
+ * @returns The required slots.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function requiredFormSpaceFileSlots(config: FormSpaceTypeConfig): FormSpaceFileSlot[];
+/**
+ * Why {@link assertFormSpaceUploadAllowed} rejected an upload.
+ *
+ * A discriminated reason rather than a bare false: the caller turns it into an error code, and a client
+ * pre-check turns it into a message the user can act on.
+ */
+export type FormSpaceUploadRejectionReason = 'not_editable' | 'unknown_slot' | 'max_uploads_reached' | 'slot_full' | 'invalid_mime_type' | 'file_too_large';
+/**
+ * Result of {@link assertFormSpaceUploadAllowed}.
+ */
+export interface FormSpaceUploadAllowedResult {
+    readonly allowed: boolean;
+    readonly reason?: Maybe<FormSpaceUploadRejectionReason>;
+}
+/**
+ * Input for {@link assertFormSpaceUploadAllowed}.
+ */
+export interface AssertFormSpaceUploadAllowedInput {
+    readonly formSpace: Pick<FormSpace, 's' | 'sat' | 'eat' | 'uc' | 'f'>;
+    readonly config: FormSpaceTypeConfig;
+    readonly slot: FormSpaceFileSlot;
+    readonly mimeType: ContentTypeMimeType;
+    readonly sizeBytes: number;
+    /**
+     * The instant to judge editability against. Defaults to now.
+     */
+    readonly now?: Maybe<Date>;
+}
+/**
+ * Decides whether one file may be uploaded into one slot of one FormSpace.
+ *
+ * THE single upload rule. The client calls it to pre-check before requesting a signed URL, and the server's
+ * upload initializer calls it again — authoritatively, after loading the space — before creating any
+ * StorageFile. The client call is a courtesy; only the server call is a control.
+ *
+ * @param input - The space, its type config, and the candidate file.
+ * @returns Whether the upload is allowed, and why not when it is not.
+ *
+ * @example
+ * ```ts
+ * const result = assertFormSpaceUploadAllowed({ formSpace, config, slot: 'resume', mimeType: 'application/pdf', sizeBytes: 4096 });
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function assertFormSpaceUploadAllowed(input: AssertFormSpaceUploadAllowedInput): FormSpaceUploadAllowedResult;
+/**
+ * Why a FormSpace cannot be submitted yet.
+ *
+ * Per-slot rather than a bare list of slot names, because "you have not uploaded a second document" and "the
+ * document you uploaded was rejected" want different words in front of the user.
+ */
+export interface FormSpaceSubmitBlocker {
+    readonly slot: FormSpaceFileSlot;
+    /**
+     * `missing_files` — the slot holds fewer than its `minFiles`.
+     * `invalid_file` — the slot holds a file validation judged INVALID.
+     * `pending_validation` — the slot holds a file whose validation has not concluded.
+     */
+    readonly reason: 'missing_files' | 'invalid_file' | 'pending_validation';
+    /**
+     * The offending files, for `invalid_file` and `pending_validation`.
+     */
+    readonly files?: Maybe<FormSpaceFile[]>;
+}
+/**
+ * Returns every reason a FormSpace may not be submitted yet, or an empty array when it may.
+ *
+ * Reads the space's own `f` array rather than querying its StorageFiles. That array is written in the
+ * accept transaction, so unlike a query it is correct immediately after an upload — and unlike a query it
+ * can be read inside the transaction that takes the submit lock.
+ *
+ * @param formSpace - The space to check.
+ * @param config - Its type config.
+ * @returns The blockers, empty when the space may be submitted.
+ *
+ * @example
+ * ```ts
+ * const blockers = formSpaceSubmitBlockers(formSpace, config);
+ *
+ * if (blockers.length > 0) {
+ *   throw formSpaceRequiredSlotMissingError(blockers.map((x) => x.slot));
+ * }
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceSubmitBlockers(formSpace: Pick<FormSpace, 'f'>, config: FormSpaceTypeConfig): FormSpaceSubmitBlocker[];
+/**
+ * What one slot of a FormSpace currently holds, and whether that satisfies the slot's own requirement.
+ *
+ * The per-slot view of {@link formSpaceSubmitBlockers}, for a UI that labels each slot individually rather
+ * than reporting one verdict for the whole space.
+ */
+export interface FormSpaceSlotStatus {
+    readonly slot: FormSpaceFileSlot;
+    /**
+     * The files the slot currently holds.
+     */
+    readonly files: FormSpaceFile[];
+    readonly minFiles: number;
+    readonly maxFiles: number;
+    /**
+     * Whether the space cannot be submitted while this slot is empty, i.e. {@link minFiles} is above zero.
+     */
+    readonly required: boolean;
+    /**
+     * Every reason this slot blocks submission. Empty when it does not.
+     */
+    readonly blockers: FormSpaceSubmitBlocker[];
+    /**
+     * Whether this slot blocks submission. An OPTIONAL EMPTY slot is satisfied — it is holding up nothing.
+     */
+    readonly satisfied: boolean;
+    /**
+     * Whether the slot is satisfied AND holds something.
+     *
+     * The distinction from {@link satisfied} is what an optional slot needs: an empty one blocks nothing, but
+     * marking it DONE claims the user dealt with it when they have not touched it. So this is the narrower
+     * predicate — "there is something here and it is fine" — and it is what a checkmark belongs next to.
+     */
+    readonly complete: boolean;
+}
+/**
+ * Input for {@link formSpaceSlotStatus}.
+ */
+export interface FormSpaceSlotStatusInput {
+    readonly formSpace: Pick<FormSpace, 'f'>;
+    readonly config: FormSpaceTypeConfig;
+    readonly slot: FormSpaceFileSlot;
+}
+/**
+ * Returns what one slot holds and whether that satisfies the slot's requirement.
+ *
+ * Derived from {@link formSpaceSubmitBlockers} rather than re-deriving the rule, so a slot a UI marks done is
+ * exactly a slot the server's submit gate would not object to.
+ *
+ * @param input - The space, its type config, and the slot to report on.
+ * @returns The slot's status.
+ *
+ * @example
+ * ```ts
+ * const status = formSpaceSlotStatus({ formSpace, config, slot: 'resume' });
+ * const showCheck = status.complete;
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceSlotStatus(input: FormSpaceSlotStatusInput): FormSpaceSlotStatus;

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

@@ -0,0 +1,13 @@
+export * from './formspace.access';
+export * from './formspace.action';
+export * from './formspace.api.error';
+export * from './formspace.api';
+export * from './formspace.id';
+export * from './formspace.permission';
+export * from './formspace.processing';
+export * from './formspace.query';
+export * from './formspace.task';
+export * from './formspace.type';
+export * from './formspace.upload';
+export * from './formspace.util';
+export * from './formspace';

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

@@ -1,4 +1,6 @@
 export * from './external';
+export * from './calendar';
+export * from './formspace';
 export * from './user';
 export * from './notification';
 export * from './oidcmodel';

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

@@ -9,6 +9,7 @@
  * before dispatching them through the configured delivery channels.
  */
 import { type PromiseOrValue, type Maybe, type WebsiteUrl, type NameEmailPair, type ArrayOrValue } from '@dereekb/util';
+import { type ICalendarIcsString, type ICalendarMethod } from '@dereekb/date';
 import { type NotificationRecipient, type NotificationRecipientWithConfig } from './notification.config';
 import { type NotificationSendFlags, type Notification, type NotificationBox } from './notification';
 import { type NotificationItem, type NotificationItemMetadata } from './notification.item';
@@ -102,6 +103,80 @@ export interface NotificationMessageContent {
      */
     readonly templateVariables?: Maybe<NotificationMessageTemplateVariables>;
 }
+/**
+ * The iTIP method a {@link NotificationMessageCalendarAttachment} may carry.
+ *
+ * Deliberately the whole of {@link ICalendarMethod}, including its open string branch. A notification
+ * USUALLY speaks as the organizer -- PUBLISH for an informational copy, REQUEST for an invitation or an
+ * update to one, ADD for extra instances of a recurring event, CANCEL to withdraw one, and DECLINECOUNTER
+ * to reject a proposed change -- but an app that sends ON BEHALF of an attendee has an equally real use
+ * for the attendee-to-organizer methods: REPLY to RSVP, REFRESH to ask for the latest copy, and COUNTER
+ * to propose one. Narrowing to the organizer set would put that behind a library change, and closing the
+ * union would also drop the `X-` extension methods {@link ICalendarMethod} intentionally leaves room for.
+ *
+ * The invariant worth enforcing is not WHICH method but that it agrees with the METHOD property inside
+ * the payload, which no type can express -- so this alias exists to document the choice rather than to
+ * constrain it.
+ */
+export type NotificationMessageCalendarAttachmentMethod = ICalendarMethod;
+/**
+ * A rendered iTIP calendar payload for a single recipient, for the sending service to bundle as a calendar
+ * MIME part on the outgoing email.
+ *
+ * Produced by a {@link NotificationMessageCalendarAttachmentFactory} at SEND time and never stored: it is
+ * not on `NotificationItem.d`, because the item is re-embedded verbatim into `NotificationSummary.n[]`
+ * (capped at 1000 items) and `NotificationWeek.n[]`, which each share a single 1 MiB document — an ICS
+ * blob in `d` would consume the summary's whole budget. Store the IDENTIFIERS in `d` and render the ICS
+ * from the message factory, which is async and holds the notification document.
+ */
+export interface NotificationMessageCalendarAttachment {
+    /**
+     * The rendered ICS document.
+     */
+    readonly ics: ICalendarIcsString;
+    /**
+     * The iTIP method the document carries. Duplicated onto the part's Content-Type by the sending service,
+     * as RFC 6047 requires, and it MUST agree with the METHOD property inside {@link ics}.
+     */
+    readonly method: NotificationMessageCalendarAttachmentMethod;
+    /**
+     * File name of the part. Defaults to "invite.ics" when the sending service is given none.
+     */
+    readonly filename?: Maybe<string>;
+}
+/**
+ * The file name given to a {@link NotificationMessageCalendarAttachment} that carries none.
+ */
+export declare const DEFAULT_NOTIFICATION_MESSAGE_CALENDAR_ATTACHMENT_FILENAME = "invite.ics";
+/**
+ * Input for a {@link NotificationMessageCalendarAttachmentFactory}.
+ */
+export interface NotificationMessageCalendarAttachmentFactoryInput {
+    /**
+     * The message the part is being built for.
+     */
+    readonly message: NotificationMessage;
+    /**
+     * The address the sending service has resolved for this recipient, and the address the payload's
+     * ATTENDEE must name.
+     *
+     * Load-bearing for a REQUEST: a client only renders an invitation inline when it finds ITS OWN address
+     * in the ATTENDEE, which is why the payload is built here rather than once per notification.
+     */
+    readonly recipient: NameEmailPair;
+}
+/**
+ * Renders the iTIP calendar payload for one recipient of a message.
+ *
+ * A factory rather than a value because the payload is per-recipient and transient: it is never
+ * serialized, it is only meaningful to a sending service that delivers email, and the ATTENDEE varies by
+ * recipient. Deferring the render to the sending service means one of these can be built once per
+ * notification, closing over the event, and the ICS is only produced for the recipients that actually
+ * receive an email.
+ *
+ * Return `undefined` to send the email without a calendar part.
+ */
+export type NotificationMessageCalendarAttachmentFactory = (input: NotificationMessageCalendarAttachmentFactoryInput) => PromiseOrValue<Maybe<NotificationMessageCalendarAttachment>>;
 export interface NotificationMessageEmailContent extends NotificationMessageContent {
     /**
      * Email subject. If not defined, defaults to the title.
@@ -133,6 +208,14 @@ export interface NotificationMessageEmailContent extends NotificationMessageCont
      * If the "replyTo" is present, this value acts as a fallback if the entity key returns no match.
      */
     readonly replyToEmail?: Maybe<NameEmailPair>;
+    /**
+     * Renders an iTIP calendar payload to bundle onto the email as a calendar MIME part.
+     *
+     * Opt-in per sending service, like every other field here: a builder that does not call it simply sends
+     * the email without the invite. A builder that DOES call it must give each recipient the payload names a
+     * request of its own, since attachments live on the request rather than the recipient.
+     */
+    readonly calendarAttachmentFactory?: Maybe<NotificationMessageCalendarAttachmentFactory>;
 }
 export interface NotificationMessageNotificationSummaryContent {
 }

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

@@ -13,6 +13,11 @@ import { type ArrayOrValue } from '@dereekb/util';
  * Used by the server to discover users whose configs need to be synced to their NotificationBox recipients.
  *
  * @returns Array of Firestore query constraints filtering for users needing sync.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationUser
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory sweep
  */
 export declare function notificationUsersFlaggedForNeedsSyncQuery(): FirestoreQueryConstraint[];
 /**
@@ -20,18 +25,34 @@ export declare function notificationUsersFlaggedForNeedsSyncQuery(): FirestoreQu
  *
  * @param exclusionId - One or more box IDs or collection name prefixes to match against.
  * @returns Array of Firestore query constraints filtering for users with matching exclusions.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationUser
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
+ * @dbxModelFirebaseIndexAllowArrayContainsAny
  */
 export declare function notificationUserHasExclusionQuery(exclusionId: ArrayOrValue<NotificationBoxSendExclusion>): FirestoreQueryConstraint[];
 /**
  * Query constraints for finding {@link NotificationSummary} documents that need server-side initialization (`s == true`).
  *
  * @returns Array of Firestore query constraints filtering for summaries needing initialization.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationSummary
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory init
  */
 export declare function notificationSummariesFlaggedForNeedsInitializationQuery(): FirestoreQueryConstraint[];
 /**
  * Query constraints for finding {@link NotificationBox} documents that need server-side initialization (`s == true`).
  *
  * @returns Array of Firestore query constraints filtering for boxes needing initialization.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationBox
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory init
  */
 export declare function notificationBoxesFlaggedForNeedsInitializationQuery(): FirestoreQueryConstraint[];
 /**
@@ -40,6 +61,11 @@ export declare function notificationBoxesFlaggedForNeedsInitializationQuery(): F
  * Used by the server to clean up boxes that could not be initialized.
  *
  * @returns Array of Firestore query constraints filtering for boxes flagged as invalid.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationBox
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory cleanup
  */
 export declare function notificationBoxesFlaggedInvalidQuery(): FirestoreQueryConstraint[];
 /**
@@ -50,6 +76,11 @@ export declare function notificationBoxesFlaggedInvalidQuery(): FirestoreQueryCo
  *
  * @param now - Reference time for the `sat` comparison (defaults to current time)
  * @returns Array of Firestore query constraints filtering for notifications past their scheduled send time.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel Notification
+ * @dbxModelFirebaseIndexScope COLLECTION_GROUP
+ * @dbxModelFirebaseIndexCategory sweep
  */
 export declare function notificationsPastSendAtTimeQuery(now?: Date): FirestoreQueryConstraint[];
 /**
@@ -57,6 +88,11 @@ export declare function notificationsPastSendAtTimeQuery(now?: Date): FirestoreQ
  * and ready to be archived to {@link NotificationWeek} and then deleted.
  *
  * @returns Array of Firestore query constraints filtering for completed notifications ready to archive.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel Notification
+ * @dbxModelFirebaseIndexScope COLLECTION_GROUP
+ * @dbxModelFirebaseIndexCategory cleanup
  */
 export declare function notificationsReadyForCleanupQuery(): FirestoreQueryConstraint[];
 /**
@@ -74,5 +110,10 @@ export declare function notificationsReadyForCleanupQuery(): FirestoreQueryConst
  * @param retentionDays - Number of days of history to retain; days strictly older than `now - retentionDays` match.
  * @param now - Reference time for the cutoff (defaults to current time)
  * @returns Array of Firestore query constraints filtering by the day string.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel NotificationLoggedEventDay
+ * @dbxModelFirebaseIndexScope COLLECTION_GROUP
+ * @dbxModelFirebaseIndexCategory cleanup
  */
 export declare function notificationLoggedEventDaysOlderThanQuery(retentionDays: number, now?: Date): FirestoreQueryConstraint[];

package/src/lib/model/oidcmodel/oidcmodel.query.d.ts

@@ -5,6 +5,11 @@ import { type OidcEntryType } from './oidcmodel';
  *
  * @param type - The OIDC entry type to filter by.
  * @returns Firestore query constraints for the given type.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcEntriesWithTypeQuery(type: OidcEntryType): FirestoreQueryConstraint[];
 /**
@@ -13,6 +18,11 @@ export declare function oidcEntriesWithTypeQuery(type: OidcEntryType): Firestore
  * @param type - The OIDC entry type to filter by.
  * @param userCode - The user code to match.
  * @returns Firestore query constraints for the given type and userCode.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcEntriesByUserCodeQuery(type: OidcEntryType, userCode: string): FirestoreQueryConstraint[];
 /**
@@ -21,6 +31,11 @@ export declare function oidcEntriesByUserCodeQuery(type: OidcEntryType, userCode
  * @param type - The OIDC entry type to filter by.
  * @param uid - The Firebase user ID to match.
  * @returns Firestore query constraints for the given type and uid.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcEntriesByUidQuery(type: OidcEntryType, uid: FirebaseAuthUserId): FirestoreQueryConstraint[];
 /**
@@ -29,6 +44,11 @@ export declare function oidcEntriesByUidQuery(type: OidcEntryType, uid: Firebase
  * @param type - The OIDC entry type to filter by.
  * @param grantId - The grant ID to match.
  * @returns Firestore query constraints for the given type and grantId.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcEntriesByGrantIdQuery(type: OidcEntryType, grantId: string): FirestoreQueryConstraint[];
 /**
@@ -37,6 +57,11 @@ export declare function oidcEntriesByGrantIdQuery(type: OidcEntryType, grantId:
  * @param type - The OIDC entry type to filter by.
  * @param clientId - The OAuth client ID to match.
  * @returns Firestore query constraints for the given type and clientId.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcEntriesByClientIdQuery(type: OidcEntryType, clientId: string): FirestoreQueryConstraint[];
 /**
@@ -44,6 +69,11 @@ export declare function oidcEntriesByClientIdQuery(type: OidcEntryType, clientId
  *
  * @param ownershipKey - The ownership key identifying the owner.
  * @returns Firestore query constraints for Client entries matching the ownership key.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
  */
 export declare function oidcClientEntriesByOwnerQuery(ownershipKey: FirebaseAuthOwnershipKey): FirestoreQueryConstraint[];
 /**
@@ -54,5 +84,11 @@ export declare function oidcClientEntriesByOwnerQuery(ownershipKey: FirebaseAuth
  *
  * @param uid - The Firebase user id the grants were issued to.
  * @returns Firestore query constraints for Grant entries matching the uid.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel OidcEntry
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
+ * @dbxModelFirebaseIndexDispatcher true
  */
 export declare function oidcGrantEntriesByUidQuery(uid: FirebaseAuthUserId): FirestoreQueryConstraint[];