@dereekb/firebase 13.42.0 → 14.0.0

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

@@ -0,0 +1,110 @@
+import { type Maybe } from '@dereekb/util';
+import { type FirestoreQueryConstraint } from '../../common/firestore/query/constraint';
+import { type FirebaseAuthOwnershipKey } from '../../common/auth/auth';
+import { type FormSpaceKey } from './formspace.id';
+/**
+ * @module formspace.query
+ *
+ * SINGLE-FIELD BY CONSTRUCTION. `firestore.indexes.json` is generated from downstream `-firebase`
+ * components and cannot resolve an identity declared upstream here, so a FormSpace query that needed a
+ * composite index would have no way to declare one. Every query below is therefore one field plus an
+ * optional sort on that same field, which Firestore serves from its automatic single-field indexes.
+ */
+/**
+ * Returns query constraints for FormSpaces awaiting a processing task (`ps == QUEUED_FOR_PROCESSING`).
+ *
+ * This is the backstop sweep: submission normally creates the task inline, so a space that is still sitting
+ * here is one whose task creation was lost.
+ *
+ * @param limitCount - Maximum number of results. Omit for unbounded.
+ * @returns Firestore query constraints for FormSpaces queued for processing.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel FormSpace
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory sweep
+ *
+ * @example
+ * ```ts
+ * const constraints = formSpacesQueuedForProcessingQuery(100);
+ * ```
+ */
+export declare function formSpacesQueuedForProcessingQuery(limitCount?: Maybe<number>): FirestoreQueryConstraint[];
+/**
+ * Input for {@link formSpacesDueForExpirationQuery}.
+ */
+export interface FormSpacesDueForExpirationQueryInput {
+    /**
+     * FormSpaces whose `eat` is at or before this instant are due.
+     *
+     * PIN THIS for the whole sweep rather than re-deriving it per page — a cutoff that advances with the
+     * clock lets a space that ages mid-sweep join a page not yet reached, making the pass unbounded.
+     */
+    readonly before: Date;
+    /**
+     * Maximum number of results per page.
+     */
+    readonly limit?: Maybe<number>;
+}
+/**
+ * Returns query constraints for FormSpaces whose expiration instant has arrived.
+ *
+ * NOTE: a Firestore inequality skips documents where the field is absent, so a space with no `eat` — one
+ * whose type does not expire, or one that has already been submitted or expired and had `eat` cleared — is
+ * not matched. That absence IS the exclusion mechanism; there is no second flag to keep in step.
+ *
+ * @param input - The pinned cutoff and page size.
+ * @returns Firestore query constraints for FormSpaces due for expiration.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel FormSpace
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory cleanup
+ *
+ * @example
+ * ```ts
+ * const constraints = formSpacesDueForExpirationQuery({ before: new Date(), limit: 50 });
+ * ```
+ */
+export declare function formSpacesDueForExpirationQuery(input: FormSpacesDueForExpirationQueryInput): FirestoreQueryConstraint[];
+/**
+ * Returns query constraints for every StorageFile that belongs to a FormSpace.
+ *
+ * A single `array-contains` on the group id, which Firestore serves from its automatic array index — the
+ * FormSpace's own group id is the only handle needed, so nothing here requires a composite index.
+ *
+ * @param formSpaceKey - The FormSpace whose files to select.
+ * @returns Firestore query constraints for the space's StorageFiles.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel StorageFile
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
+ * @dbxModelFirebaseIndexSkip true
+ *
+ * @example
+ * ```ts
+ * const constraints = storageFilesForFormSpaceQuery('fsp/abc123');
+ * ```
+ */
+export declare function storageFilesForFormSpaceQuery(formSpaceKey: FormSpaceKey): FirestoreQueryConstraint[];
+/**
+ * Returns query constraints for every FormSpace carrying the given ownership key.
+ *
+ * Ordering is deliberately left to the caller/client: a second field here would need a composite index this
+ * package has no way to declare.
+ *
+ * @param ownerKey - The ownership key to filter by.
+ * @returns Firestore query constraints for the owner's FormSpaces.
+ *
+ * @dbxModelFirebaseIndex
+ * @dbxModelFirebaseIndexModel FormSpace
+ * @dbxModelFirebaseIndexScope COLLECTION
+ * @dbxModelFirebaseIndexCategory lookup
+ *
+ * @example
+ * ```ts
+ * const constraints = formSpacesForOwnerQuery('pr/abc123');
+ * ```
+ */
+export declare function formSpacesForOwnerQuery(ownerKey: FirebaseAuthOwnershipKey): FirestoreQueryConstraint[];

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

@@ -0,0 +1,136 @@
+import { type Maybe } from '@dereekb/util';
+import { type CreateNotificationTaskTemplate } from '../notification/notification.create.task';
+import { type NotificationTaskSubtaskCheckpointString, type NotificationTaskSubtaskData, type NotificationTaskSubtaskMetadata } from '../notification/notification.task.subtask';
+import { type NotificationTaskType, type NotificationTaskUniqueId } from '../notification/notification.id';
+import { type FormSpaceDocument } from './formspace';
+import { type FormSpaceId, type FormSpaceType } from './formspace.id';
+/**
+ * @module formspace.task
+ *
+ * The NotificationTask that processes a submitted FormSpace.
+ *
+ * ONE task type for every form type. The task's SUBTASK TARGET is the {@link FormSpaceType}, so a new form
+ * type registers a processor rather than a task type — the same specialization
+ * `StorageFileProcessingNotificationTask` already does by purpose.
+ *
+ * ONE task per SUBMISSION ATTEMPT, not per space. A unique task's document id is derived and permanent, and
+ * a completed task is only marked done (`d`) — it lingers until the cleanup sweep collects it. So a space
+ * that is reopened and resubmitted would re-derive the id of its own finished task, and
+ * `createOrRunUniqueNotificationDocument` would find it already there and do nothing at all: the space
+ * would sit in QUEUED_FOR_PROCESSING pointing at a dead document forever. Keying the id by the space's
+ * reopen count is what keeps each attempt a document of its own, and the first attempt keeps the exact id
+ * it has always had.
+ */
+/**
+ * NotificationTask type identifier for FormSpace submission processing.
+ */
+export declare const FORM_SPACE_SUBMISSION_NOTIFICATION_TASK_TYPE: NotificationTaskType;
+/**
+ * Checkpoint string for a FormSpace submission subtask.
+ */
+export type FormSpaceSubmissionSubtask = NotificationTaskSubtaskCheckpointString;
+/**
+ * Arbitrary metadata carried between a FormSpace submission's subtasks.
+ */
+export type FormSpaceSubmissionSubtaskMetadata = NotificationTaskSubtaskMetadata;
+/**
+ * Data payload for a FormSpace submission NotificationTask.
+ *
+ * @template M - subtask metadata type
+ * @template S - subtask checkpoint string type
+ */
+export interface FormSpaceSubmissionNotificationTaskData<M extends FormSpaceSubmissionSubtaskMetadata = FormSpaceSubmissionSubtaskMetadata, S extends FormSpaceSubmissionSubtask = FormSpaceSubmissionSubtask> extends NotificationTaskSubtaskData<M, S> {
+    /**
+     * The FormSpaceDocument id.
+     */
+    readonly formSpace: FormSpaceId;
+    /**
+     * The FormSpace's type, which is also the subtask target.
+     *
+     * Retrieved from the FormSpace the first time the task runs and re-copied onto the metadata afterwards,
+     * so subsequent runs do not re-read the document only to learn which processor to dispatch to.
+     */
+    readonly t?: Maybe<FormSpaceType>;
+    /**
+     * The space's reopen count when this task was created — the submission ATTEMPT this task belongs to.
+     *
+     * The handler compares it against the space's current count and terminates when they differ. Without
+     * that fence a task left over from a superseded attempt would process the reopened space's new content
+     * and its cleanup would write `ps`/`cpat`/`pn` over the attempt actually in force. Absent on a task
+     * created before attempt-keying existed, which is read as "do not fence".
+     */
+    readonly rc?: Maybe<number>;
+}
+/**
+ * Input for {@link formSpaceSubmissionNotificationTaskTemplate}.
+ */
+export interface FormSpaceSubmissionNotificationTaskInput<M extends FormSpaceSubmissionSubtaskMetadata = FormSpaceSubmissionSubtaskMetadata> extends Omit<FormSpaceSubmissionNotificationTaskData<M>, 'formSpace' | 't' | 'sfps' | 'rc'> {
+    readonly formSpaceDocument: FormSpaceDocument;
+    /**
+     * The space's current reopen count — the attempt this task is for. Defaults to 0, the first submission.
+     */
+    readonly reopenCount?: Maybe<number>;
+    readonly overrideExistingTask?: Maybe<boolean>;
+}
+/**
+ * Input for {@link formSpaceSubmissionNotificationTaskUniqueId}.
+ */
+export interface FormSpaceSubmissionNotificationTaskUniqueIdInput {
+    readonly formSpaceId: FormSpaceId;
+    /**
+     * The attempt's reopen count. Defaults to 0, the first submission.
+     */
+    readonly reopenCount?: Maybe<number>;
+}
+/**
+ * Returns the unique NotificationTask document id processing one SUBMISSION ATTEMPT of a FormSpace.
+ *
+ * The first attempt is the bare {@link notificationTaskUniqueId}, unsuffixed, so a space submitted before
+ * reopening existed keeps the exact document it already has. Every attempt after a reopen appends its
+ * count, which is what stops a resubmit from colliding with the finished task of the attempt before it.
+ *
+ * The `r` between the separators keeps the suffix from ever being able to produce a `__` run, whatever a
+ * FormSpace id happens to contain — Firestore reserves ids wrapped in double underscores, and staying well
+ * clear of them costs one character.
+ *
+ * Exported so a caller that has to LOCATE an attempt's task — a test asserting which document a resubmit
+ * created, or tooling inspecting a stuck submission — derives the id the same way the template does. The
+ * reopen action deliberately does not need it: the superseded attempt's task is left alone, either already
+ * done and awaiting the cleanup sweep or still queued and about to fence itself off.
+ *
+ * @param input - The FormSpace id and the attempt's reopen count.
+ * @returns The unique notification task id.
+ *
+ * @example
+ * ```ts
+ * formSpaceSubmissionNotificationTaskUniqueId({ formSpaceId: 'abc' }); // 'abc_FSPS'
+ * formSpaceSubmissionNotificationTaskUniqueId({ formSpaceId: 'abc', reopenCount: 2 }); // 'abc_FSPS_r2'
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function formSpaceSubmissionNotificationTaskUniqueId(input: FormSpaceSubmissionNotificationTaskUniqueIdInput): NotificationTaskUniqueId;
+/**
+ * Creates a {@link CreateNotificationTaskTemplate} for a FormSpace submission task.
+ *
+ * The task is UNIQUE to one submission ATTEMPT of the FormSpace. Within an attempt that uniqueness is what
+ * makes a second template resolve to the same document rather than racing a second processor against the
+ * first; across attempts, {@link formSpaceSubmissionNotificationTaskUniqueId} keys them apart so a resubmit
+ * after a reopen gets a document — and a checkpoint flow — of its own.
+ *
+ * @param input - The target FormSpaceDocument, its reopen count, and optional subtask data.
+ * @returns A CreateNotificationTaskTemplate for the submission task.
+ *
+ * @example
+ * ```ts
+ * const template = formSpaceSubmissionNotificationTaskTemplate({ formSpaceDocument: doc, reopenCount: formSpace.rc });
+ * ```
+ */
+export declare function formSpaceSubmissionNotificationTaskTemplate(input: FormSpaceSubmissionNotificationTaskInput): CreateNotificationTaskTemplate;
+/**
+ * All NotificationTask types used by the FormSpace system.
+ *
+ * Register these with the notification task service so an unhandled type is caught at wiring time rather
+ * than at the first submission.
+ */
+export declare const ALL_FORM_SPACE_NOTIFICATION_TASK_TYPES: NotificationTaskType[];

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

@@ -0,0 +1,300 @@
+import { type ContentTypeMimeType, type Maybe, type Milliseconds } from '@dereekb/util';
+import { type FormSpaceFileSlot, type FormSpaceType } from './formspace.id';
+/**
+ * @module formspace.type
+ *
+ * The {@link FormSpaceType} registry: the per-type upload restrictions, expiration policy, and submission
+ * metadata an app declares once and both the client and the server read.
+ *
+ * The type and the factory live here, in the model folder rather than in `firebase-server`, so a client-side
+ * pre-check rejects an oversized file with the SAME rule the server enforces authoritatively. Only the
+ * service INSTANCE is constructed server-side, as a NestJS provider — the same split
+ * {@link AppCalendarTypeConfigService} uses.
+ */
+/**
+ * Who may read and remove an individual file, among the users who already reach the FormSpace itself.
+ *
+ * Narrows access; it never widens it. A caller that cannot read the space at all is refused before this is
+ * ever consulted, so `'space'` is not "public" — it is "whoever the space already lets in".
+ *
+ * - `'space'` — anyone holding the corresponding role on the space. The DEFAULT, and the only sensible
+ *   answer for a single-user form, where every file was uploaded by the one person who can reach it.
+ * - `'uploader'` — only the user who uploaded that file, per {@link FormSpaceFile.ub}. For a SHARED space
+ *   whose members contribute side by side rather than collaborating on one pile: a member adds their own
+ *   photos and can take them back, and cannot read or delete anybody else's. The space's own `u` is NOT
+ *   exempt — on a shared space `u` is whoever the space was opened for, not an administrator of its
+ *   contents, and exempting them would quietly hand one member the whole album.
+ */
+export type FormSpaceFileAccess = 'space' | 'uploader';
+/**
+ * Default for {@link FormSpaceFileSlotConfig.fileAccess} and {@link FormSpaceTypeConfig.fileAccess}.
+ *
+ * `'space'`, so a type declared before per-file access existed keeps behaving exactly as it did.
+ */
+export declare const DEFAULT_FORM_SPACE_FILE_ACCESS: FormSpaceFileAccess;
+/**
+ * Restrictions for a single named upload slot within a {@link FormSpaceTypeConfig}.
+ *
+ * A slot is a LOGICAL position, not a file: uploading into an occupied slot supersedes what was there, so
+ * "one current resume" needs no extra bookkeeping.
+ */
+export interface FormSpaceFileSlotConfig {
+    /**
+     * The slot this configuration applies to.
+     */
+    readonly slot: FormSpaceFileSlot;
+    /**
+     * Human-readable name of the slot, for tooling and logs.
+     */
+    readonly name?: Maybe<string>;
+    /**
+     * Whether the space may be submitted without a file in this slot. Defaults to false.
+     */
+    readonly required?: Maybe<boolean>;
+    /**
+     * Mime types accepted in this slot. Defaults to the type's {@link FormSpaceTypeConfig.allowedMimeTypes}.
+     */
+    readonly allowedMimeTypes?: Maybe<readonly ContentTypeMimeType[]>;
+    /**
+     * Size cap for a file in this slot. Defaults to the type's {@link FormSpaceTypeConfig.maxFileSizeBytes}.
+     */
+    readonly maxFileSizeBytes?: Maybe<number>;
+    /**
+     * How many files this slot may hold at once. Defaults to {@link DEFAULT_FORM_SPACE_SLOT_MAX_FILES}.
+     *
+     * At 1 the slot is a POSITION: a new upload supersedes whatever was there, which is the original "one
+     * current resume" behaviour. Above 1 it is a FOLDER: uploads accumulate, and one is refused once the
+     * folder is full rather than quietly evicting the oldest file the user put there.
+     */
+    readonly maxFiles?: Maybe<number>;
+    /**
+     * How many files this slot must hold before the space may be submitted.
+     *
+     * Defaults to 1 when {@link required} is true, and 0 otherwise, so `required` keeps meaning exactly what it
+     * meant before folders existed.
+     */
+    readonly minFiles?: Maybe<number>;
+    /**
+     * Who may read and remove an individual file in this slot.
+     *
+     * Defaults to the type's {@link FormSpaceTypeConfig.fileAccess}, which itself defaults to
+     * {@link DEFAULT_FORM_SPACE_FILE_ACCESS}. Narrowing it per slot is what lets one shared space hold a
+     * public banner everybody sees alongside a folder of each member's own documents.
+     */
+    readonly fileAccess?: Maybe<FormSpaceFileAccess>;
+    /**
+     * Whether a file here must pass validation before the space may be submitted. Defaults to false.
+     *
+     * Setting it does two things: an accepted upload enters the StorageFile processing pipeline instead of
+     * being stored as-is, and a file left PENDING or judged INVALID blocks submission. A type that sets this
+     * MUST register a validator for the slot server-side; the wiring asserts that at boot.
+     */
+    readonly validationRequired?: Maybe<boolean>;
+}
+/**
+ * Upload, expiration, and submission configuration for a single {@link FormSpaceType}.
+ *
+ * This is the contract a FormSpace of the type is held to. It is pure data and is shared by the client and
+ * the server; the server-side PROCESSING of a submission is registered separately, as a
+ * `FormSpaceSubmissionProcessorConfig` keyed by the same type string.
+ */
+export interface FormSpaceTypeConfig {
+    /**
+     * The type this configuration applies to.
+     */
+    readonly formSpaceType: FormSpaceType;
+    /**
+     * Human-readable name of the type, for tooling and logs.
+     */
+    readonly name?: Maybe<string>;
+    /**
+     * Longer description of what the type collects.
+     */
+    readonly description?: Maybe<string>;
+    /**
+     * The upload slots this type declares.
+     *
+     * When empty, the type accepts no uploads at all — a FormSpace can be a pure JSON container.
+     */
+    readonly slots?: Maybe<readonly FormSpaceFileSlotConfig[]>;
+    /**
+     * Whether a slot NOT declared in {@link slots} may be uploaded into. Defaults to false.
+     *
+     * False is the safe default: an undeclared slot has no size or mime restriction of its own, so allowing
+     * one silently widens the type's contract to the global defaults.
+     */
+    readonly allowUndeclaredSlots?: Maybe<boolean>;
+    /**
+     * Maximum number of uploads a single FormSpace of this type may ACCEPT over its whole lifetime.
+     *
+     * Counted against the space's monotonic `uc` counter, which is why superseding a slot still consumes one:
+     * the cap bounds work done, not files retained. Defaults to {@link DEFAULT_FORM_SPACE_MAX_UPLOADS}.
+     */
+    readonly maxUploads?: Maybe<number>;
+    /**
+     * Mime types accepted by any slot that does not narrow them further.
+     * Defaults to {@link DEFAULT_FORM_SPACE_ALLOWED_MIME_TYPES}.
+     */
+    readonly allowedMimeTypes?: Maybe<readonly ContentTypeMimeType[]>;
+    /**
+     * Size cap for any slot that does not narrow it further.
+     * Defaults to {@link DEFAULT_FORM_SPACE_MAX_FILE_SIZE_BYTES}.
+     */
+    readonly maxFileSizeBytes?: Maybe<number>;
+    /**
+     * Who may read and remove an individual file in any slot that does not narrow it further.
+     * Defaults to {@link DEFAULT_FORM_SPACE_FILE_ACCESS}.
+     */
+    readonly fileAccess?: Maybe<FormSpaceFileAccess>;
+    /**
+     * How long a newly created FormSpace of this type stays editable before the expiration sweep retires it.
+     *
+     * When absent the space never expires and `eat` is never written, which is exactly what keeps it out of
+     * the sweep's inequality query.
+     */
+    readonly expiresIn?: Maybe<Milliseconds>;
+    /**
+     * How long after EACH submission a space of this type may be reopened, returning it to an editable draft.
+     *
+     * THE MASTER SWITCH. When absent the type is never reopenable and submission stays the one-way door it
+     * has always been — which is what makes the whole reopen feature opt-in, and why no existing type can
+     * acquire resubmit semantics by accident.
+     *
+     * Distinct from {@link expiresIn}, which bounds the lifetime of the DRAFT. This bounds the lifetime of
+     * the SUBMISSION's mutability.
+     *
+     * Rolling by default: absent {@link reopenableUntil}, every submission grants a fresh window measured
+     * from its own `sat`.
+     */
+    readonly reopenableFor?: Maybe<Milliseconds>;
+    /**
+     * A hard ceiling on reopening, measured from the FIRST submission rather than the current one.
+     *
+     * Materialized onto the space as `lat` on its first submit and never moved, so repeated reopen/resubmit
+     * rounds cannot walk the deadline forward the way a purely rolling {@link reopenableFor} lets them. Use
+     * it when "this submission is final N hours after it was first made" has to be a wall-clock guarantee.
+     *
+     * Absent leaves {@link reopenableFor} rolling. Meaningless on its own: {@link reopenableFor} is what
+     * permits a reopen at all, and this only narrows it.
+     */
+    readonly reopenableUntil?: Maybe<Milliseconds>;
+    /**
+     * How many times a space of this type may be reopened. Counted against the space's monotonic `rc`.
+     *
+     * Absent leaves the count unbounded and the windows above the only limit — which is fine for a
+     * {@link reopenableUntil} ceiling, and worth setting deliberately for a purely rolling window, where a
+     * resubmit keeps earning a new one.
+     */
+    readonly maxReopens?: Maybe<number>;
+}
+/**
+ * Default for {@link FormSpaceTypeConfig.maxUploads}.
+ */
+export declare const DEFAULT_FORM_SPACE_MAX_UPLOADS = 20;
+/**
+ * Default for {@link FormSpaceFileSlotConfig.maxFiles}.
+ *
+ * One, so a slot declared before folders existed keeps superseding rather than silently accumulating.
+ */
+export declare const DEFAULT_FORM_SPACE_SLOT_MAX_FILES = 1;
+/**
+ * Default for {@link FormSpaceTypeConfig.maxFileSizeBytes}: 10 MiB.
+ */
+export declare const DEFAULT_FORM_SPACE_MAX_FILE_SIZE_BYTES: number;
+/**
+ * Default for {@link FormSpaceTypeConfig.allowedMimeTypes}.
+ *
+ * Deliberately narrow: a form attachment is a document or an image, and an open list on the DEFAULT path is
+ * how an upload endpoint becomes a general-purpose file host.
+ */
+export declare const DEFAULT_FORM_SPACE_ALLOWED_MIME_TYPES: readonly ContentTypeMimeType[];
+/**
+ * Default expiration applied to {@link DEFAULT_FORM_SPACE_TYPE_CONFIG}-shaped types that opt in: seven days.
+ */
+export declare const DEFAULT_FORM_SPACE_EXPIRES_IN: Milliseconds;
+/**
+ * The {@link FormSpaceType} of {@link DEFAULT_FORM_SPACE_TYPE_CONFIG}, used for a type the app never registered.
+ */
+export declare const UNKNOWN_FORM_SPACE_TYPE: FormSpaceType;
+/**
+ * The configuration applied to a FormSpace whose type the app did not register.
+ *
+ * An unregistered type falls back rather than throwing on purpose: a scheduled sweep over every FormSpace in
+ * the app must not be taken down by one badly-typed document. CREATION is the opposite — `createFormSpace`
+ * rejects an unregistered type outright, so this fallback only ever governs a document that already exists.
+ *
+ * It declares no slots and does not allow undeclared ones, so an unregistered space accepts no uploads.
+ */
+export declare const DEFAULT_FORM_SPACE_TYPE_CONFIG: FormSpaceTypeConfig;
+/**
+ * Record of {@link FormSpaceTypeConfig} keyed by {@link FormSpaceType}.
+ */
+export type FormSpaceTypeConfigRecord = Record<FormSpaceType, FormSpaceTypeConfig>;
+/**
+ * Creates a {@link FormSpaceTypeConfigRecord} from an array of configs.
+ *
+ * @param configs - The configs to index.
+ * @returns A record keyed by form space type.
+ * @throws {Error} When two configs declare the same {@link FormSpaceType}.
+ *
+ * @example
+ * ```ts
+ * const record = formSpaceTypeConfigRecord([{ formSpaceType: 'demo_example' }]);
+ * ```
+ */
+export declare function formSpaceTypeConfigRecord(configs: FormSpaceTypeConfig[]): FormSpaceTypeConfigRecord;
+/**
+ * Runtime service for resolving a {@link FormSpaceTypeConfig} from a {@link FormSpaceType}.
+ *
+ * Built from a {@link FormSpaceTypeConfigRecord} via {@link appFormSpaceTypeConfigService}.
+ */
+export declare abstract class AppFormSpaceTypeConfigService {
+    /**
+     * All registered configs for this app.
+     */
+    abstract readonly appFormSpaceTypeConfigRecord: FormSpaceTypeConfigRecord;
+    /**
+     * Returns the config for the given type, falling back to the service's default when it is not registered.
+     *
+     * @param formSpaceType - The type to look up.
+     */
+    abstract configForFormSpaceType(formSpaceType: FormSpaceType): FormSpaceTypeConfig;
+    /**
+     * Returns the config for the given type, or null when it is not registered.
+     *
+     * This is what `createFormSpace` gates on: a space may only be CREATED for a type the app declared.
+     *
+     * @param formSpaceType - The type to look up.
+     */
+    abstract registeredConfigForFormSpaceType(formSpaceType: FormSpaceType): Maybe<FormSpaceTypeConfig>;
+    /**
+     * Returns every registered {@link FormSpaceType}.
+     */
+    abstract getAllKnownFormSpaceTypes(): FormSpaceType[];
+    /**
+     * Returns every registered {@link FormSpaceTypeConfig}.
+     */
+    abstract getAllKnownFormSpaceTypeConfigs(): FormSpaceTypeConfig[];
+}
+/**
+ * Reference to an {@link AppFormSpaceTypeConfigService} instance, for dependency injection.
+ */
+export interface AppFormSpaceTypeConfigServiceRef {
+    readonly appFormSpaceTypeConfigService: AppFormSpaceTypeConfigService;
+}
+/**
+ * Creates an {@link AppFormSpaceTypeConfigService} from the given record.
+ *
+ * @param appFormSpaceTypeConfigRecord - The complete form space type registry for the application.
+ * @param defaultConfig - Config used for an unregistered type. Defaults to {@link DEFAULT_FORM_SPACE_TYPE_CONFIG}.
+ * @returns The service.
+ *
+ * @example
+ * ```ts
+ * const service = appFormSpaceTypeConfigService(formSpaceTypeConfigRecord(DEMO_FORM_SPACE_TYPE_CONFIGS));
+ * const config = service.configForFormSpaceType('demo_example');
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function appFormSpaceTypeConfigService(appFormSpaceTypeConfigRecord: FormSpaceTypeConfigRecord, defaultConfig?: FormSpaceTypeConfig): AppFormSpaceTypeConfigService;