@momentumcms/admin 0.0.1

package/types/momentumcms-admin.d.ts

@@ -0,0 +1,3706 @@
+import { Routes, CanActivateFn, CanDeactivateFn } from '@angular/router';
+import * as _angular_core from '@angular/core';
+import { Type, InjectionToken, Signal, Provider, OnInit, WritableSignal, ElementRef } from '@angular/core';
+import { CollectionConfig, GlobalConfig, PluginAdminRouteDescriptor, MomentumPlugin, MomentumConfig, MediaDocument, AdminConfig, Field, DocumentStatus as DocumentStatus$1, BlockConfig, UploadField } from '@momentumcms/core';
+import { HttpContextToken, HttpInterceptorFn } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DataTableColumn, DataTableSort, DataTableRowAction, DataTableRowActionEvent, FieldDisplayType, FieldDisplayFieldMeta, FieldDisplayNumberFormat, FieldDisplayDateFormat, PopoverTrigger, ValidationError, SelectOption } from '@momentumcms/ui';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { SafeResourceUrl } from '@angular/platform-browser';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+/**
+ * Momentum Admin Routes Factory
+ *
+ * Creates Angular routes for the admin UI that can be integrated into
+ * any Angular application or Analog.js app.
+ *
+ * Usage in Angular:
+ * ```typescript
+ * import { momentumAdminRoutes } from '@momentumcms/admin';
+ * import { collections } from './collections';
+ *
+ * export const routes: Routes = [
+ *   ...momentumAdminRoutes({
+ *     basePath: '/admin',
+ *     collections,
+ *   }),
+ * ];
+ * ```
+ */
+
+interface MomentumAdminBranding {
+    /** Logo URL */
+    logo?: string;
+    /** Site title */
+    title?: string;
+    /** Primary color (CSS color value) */
+    primaryColor?: string;
+}
+/**
+ * Admin plugin route descriptor with Angular-typed loadComponent.
+ * Mirrors Angular Route concepts (path, loadComponent, data) with
+ * additional Momentum sidebar metadata (label, icon, group).
+ */
+interface AdminPluginRoute {
+    /** Route path under admin (e.g., 'analytics') — same as Angular Route.path */
+    path: string;
+    /** Lazy component loader — same as Angular Route.loadComponent */
+    loadComponent: () => Promise<Type<unknown>>;
+    /** Optional route data — same as Angular Route.data */
+    data?: Record<string, unknown>;
+    /** Sidebar display label */
+    label: string;
+    /** Icon name from ng-icons (e.g., 'heroChartBarSquare') */
+    icon: string;
+    /** Sidebar section name. @default 'Plugins' */
+    group?: string;
+}
+interface MomentumAdminOptions {
+    /** Base path for admin routes (e.g., '/admin') */
+    basePath: string;
+    /** Collection configurations */
+    collections: CollectionConfig[];
+    /** Global configurations (singleton documents) */
+    globals?: GlobalConfig[];
+    /** Optional branding customization */
+    branding?: MomentumAdminBranding;
+    /** Whether to include auth routes (login, setup). Defaults to true */
+    includeAuthRoutes?: boolean;
+    /** Plugin-registered admin routes. Accepts both Angular-typed and core-typed descriptors. */
+    pluginRoutes?: AdminPluginRoute[] | PluginAdminRouteDescriptor[];
+    /** Plugins — their static collections and admin routes are merged automatically. */
+    plugins?: MomentumPlugin[];
+}
+interface MomentumAdminRouteData {
+    collections: CollectionConfig[];
+    globals?: GlobalConfig[];
+    branding?: MomentumAdminBranding;
+    pluginRoutes?: AdminPluginRoute[];
+}
+/**
+ * Creates Angular routes for the Momentum CMS admin UI.
+ *
+ * Can be called with a full `MomentumConfig` (config-driven) or explicit options.
+ *
+ * Config-driven usage (recommended):
+ * ```typescript
+ * import config from '../momentum.config';
+ * export const routes = [...momentumAdminRoutes(config)];
+ * ```
+ *
+ * Options-based usage:
+ * ```typescript
+ * momentumAdminRoutes({ basePath: '/admin', collections, branding })
+ * ```
+ */
+declare function momentumAdminRoutes(config: MomentumConfig): Routes;
+declare function momentumAdminRoutes(options: MomentumAdminOptions): Routes;
+
+/**
+ * Set this context token to `true` on any HTTP request to skip
+ * the automatic CUD toast for that specific request.
+ *
+ * @example
+ * ```typescript
+ * const context = new HttpContext().set(SKIP_AUTO_TOAST, true);
+ * this.http.post('/api/posts', data, { context });
+ * ```
+ */
+declare const SKIP_AUTO_TOAST: HttpContextToken<boolean>;
+/**
+ * HTTP interceptor that automatically shows toast notifications
+ * for CUD (Create, Update, Delete) operations on collection API endpoints.
+ *
+ * Handles both success and error responses:
+ * - Success: Shows appropriate created/updated/deleted toast
+ * - Error 400 with validation errors: Shows validation failed toast
+ * - Error 403: Shows not authorized toast
+ * - Error 404: Shows entity not found toast
+ * - Other errors: Shows generic operation failed toast
+ *
+ * Use `SKIP_AUTO_TOAST` context token to opt out for specific requests.
+ */
+declare const crudToastInterceptor: HttpInterceptorFn;
+
+/**
+ * Momentum CMS API Service
+ *
+ * Handles communication with the Momentum CMS REST API.
+ */
+declare class MomentumApiService {
+    private readonly http;
+    private readonly baseUrl;
+    /**
+     * Fetch all documents from a collection
+     */
+    findAll(collection: string): Observable<Record<string, unknown>[]>;
+    /**
+     * Fetch a single document by ID
+     */
+    findById(collection: string, id: string): Observable<Record<string, unknown> | null>;
+    /**
+     * Create a new document
+     */
+    create(collection: string, data: Record<string, unknown>): Observable<Record<string, unknown>>;
+    /**
+     * Update an existing document
+     */
+    update(collection: string, id: string, data: Record<string, unknown>): Observable<Record<string, unknown>>;
+    /**
+     * Delete a document
+     */
+    delete(collection: string, id: string): Observable<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MomentumApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MomentumApiService>;
+}
+
+/**
+ * Response type for the setup status endpoint.
+ */
+interface SetupStatus {
+    /** True if no users exist and setup is required */
+    needsSetup: boolean;
+    /** True if at least one user exists */
+    hasUsers: boolean;
+}
+/**
+ * User data returned from Better Auth.
+ */
+interface AuthUser {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+    emailVerified: boolean;
+    twoFactorEnabled?: boolean;
+    image?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Session data from Better Auth.
+ */
+interface AuthSession {
+    id: string;
+    userId: string;
+    token: string;
+    expiresAt: string;
+}
+/**
+ * Result type for auth operations.
+ */
+interface AuthResult {
+    success: boolean;
+    error?: string;
+    user?: AuthUser;
+}
+/**
+ * Result type for enabling two-factor authentication.
+ */
+interface TwoFactorEnableResult {
+    success: boolean;
+    error?: string;
+    totpURI?: string;
+    backupCodes?: string[];
+}
+/**
+ * Momentum Auth Service
+ *
+ * Manages authentication state using signals and communicates with Better Auth
+ * endpoints on the server.
+ *
+ * @example
+ * ```typescript
+ * const auth = inject(MomentumAuthService);
+ *
+ * // Check if authenticated
+ * if (auth.isAuthenticated()) {
+ *   console.log('User:', auth.user()?.name);
+ * }
+ *
+ * // Sign in
+ * const result = await auth.signIn('user@example.com', 'password');
+ * if (!result.success) {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare class MomentumAuthService {
+    private readonly http;
+    private readonly document;
+    private readonly baseUrl;
+    /** Current authenticated user */
+    readonly user: _angular_core.WritableSignal<AuthUser | null>;
+    /** Whether auth state is being loaded */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Whether the app needs initial setup (no users exist) */
+    readonly needsSetup: _angular_core.WritableSignal<boolean>;
+    /** Whether a user is currently authenticated */
+    readonly isAuthenticated: _angular_core.Signal<boolean>;
+    /** Current user's role */
+    readonly role: _angular_core.Signal<string | null>;
+    /** Whether current user is an admin */
+    readonly isAdmin: _angular_core.Signal<boolean>;
+    /** Whether current user has verified their email */
+    readonly emailVerified: _angular_core.Signal<boolean>;
+    /** Tracks in-flight initialization to prevent duplicate requests */
+    private initPromise;
+    /**
+     * Initialize auth state by checking current session.
+     * Should be called on app startup. Safe to call concurrently from multiple guards.
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Check if the application needs initial setup (no users exist).
+     */
+    checkSetupStatus(): Promise<SetupStatus>;
+    /**
+     * Refresh the current session from the server.
+     */
+    refreshSession(): Promise<AuthUser | null>;
+    /**
+     * Fetch the current user from the Momentum session resolver,
+     * which has the correctly-resolved role from the users collection.
+     * Better Auth's get-session returns the default role, not the Momentum role.
+     */
+    private resolveUserRole;
+    /**
+     * Sign in with email and password.
+     */
+    signIn(email: string, password: string): Promise<AuthResult>;
+    /**
+     * Sign up a new user with email and password.
+     *
+     * @param name User's display name
+     * @param email User's email address
+     * @param password User's password (min 8 characters)
+     * @param isFirstUser If true, grants admin role (for setup flow)
+     */
+    signUp(name: string, email: string, password: string, isFirstUser?: boolean): Promise<AuthResult>;
+    /**
+     * Sign out the current user.
+     */
+    signOut(): Promise<void>;
+    /**
+     * Request a password reset email.
+     *
+     * @param email The email address to send the reset link to
+     * @param redirectTo URL to redirect user after clicking the reset link (defaults to /admin/reset-password)
+     * @returns Always returns success to prevent email enumeration attacks
+     */
+    requestPasswordReset(email: string, redirectTo?: string): Promise<AuthResult>;
+    /**
+     * Reset password using a reset token.
+     *
+     * @param token The reset token from the email link
+     * @param newPassword The new password to set
+     */
+    resetPassword(token: string, newPassword: string): Promise<AuthResult>;
+    /** Whether current user has 2FA enabled */
+    readonly twoFactorEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Enable two-factor authentication for the current user.
+     * Returns the TOTP URI (for QR code generation) and backup codes.
+     */
+    enableTwoFactor(password: string): Promise<TwoFactorEnableResult>;
+    /**
+     * Verify a TOTP code to complete 2FA setup or sign-in.
+     */
+    verifyTOTP(code: string, trustDevice?: boolean): Promise<AuthResult>;
+    /**
+     * Disable two-factor authentication for the current user.
+     */
+    disableTwoFactor(password: string): Promise<AuthResult>;
+    /**
+     * Get the list of enabled OAuth providers from the server.
+     */
+    getOAuthProviders(): Promise<string[]>;
+    /**
+     * Initiate OAuth sign-in by redirecting to the provider's authorization page.
+     * Better Auth handles the redirect flow via /api/auth/sign-in/social.
+     *
+     * @param provider The OAuth provider name (e.g., 'google', 'github')
+     * @param callbackURL URL to redirect to after successful authentication
+     */
+    signInWithOAuth(provider: string, callbackURL?: string): void;
+    /**
+     * Extract error message from HTTP error response.
+     */
+    private extractErrorMessage;
+    /**
+     * Type guard for HTTP error responses with message.
+     */
+    private isHttpErrorWithMessage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MomentumAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MomentumAuthService>;
+}
+
+/**
+ * Permissions for a single collection.
+ */
+interface CollectionPermissions {
+    slug: string;
+    canAccess: boolean;
+    canCreate: boolean;
+    canRead: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+}
+/**
+ * Collection Access Service
+ *
+ * Manages collection-level access permissions for the admin panel.
+ * Fetches permissions from the server and provides reactive state
+ * for guards and components to use.
+ *
+ * @example
+ * ```typescript
+ * const accessService = inject(CollectionAccessService);
+ *
+ * // Load permissions
+ * await accessService.loadAccess();
+ *
+ * // Check access
+ * if (accessService.canAccess('posts')) {
+ *   // Show posts collection
+ * }
+ *
+ * // Check specific operation
+ * if (accessService.canCreate('posts')) {
+ *   // Show create button
+ * }
+ * ```
+ */
+declare class CollectionAccessService {
+    private readonly http;
+    /** Full permissions for all collections */
+    private readonly _permissions;
+    /** Whether permissions are being loaded */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Whether permissions have been loaded at least once */
+    readonly initialized: _angular_core.WritableSignal<boolean>;
+    /** Error message if loading failed */
+    readonly error: _angular_core.WritableSignal<string | null>;
+    /** All collection permissions (read-only) */
+    readonly permissions: _angular_core.Signal<CollectionPermissions[]>;
+    /** Slugs of collections the user can access in admin panel */
+    readonly accessibleCollections: _angular_core.Signal<string[]>;
+    /** Tracks in-flight load to prevent duplicate requests */
+    private loadPromise;
+    /**
+     * Load collection permissions from the server.
+     * Should be called when the user authenticates or on app init.
+     * Safe to call concurrently from multiple guards.
+     */
+    loadAccess(): Promise<void>;
+    private doLoadAccess;
+    /**
+     * Reset permissions state.
+     * Should be called when the user logs out.
+     */
+    reset(): void;
+    /**
+     * Check if the user can access a collection in the admin panel.
+     */
+    canAccess(slug: string): boolean;
+    /**
+     * Check if the user can create documents in a collection.
+     */
+    canCreate(slug: string): boolean;
+    /**
+     * Check if the user can read documents in a collection.
+     */
+    canRead(slug: string): boolean;
+    /**
+     * Check if the user can update documents in a collection.
+     */
+    canUpdate(slug: string): boolean;
+    /**
+     * Check if the user can delete documents in a collection.
+     */
+    canDelete(slug: string): boolean;
+    /**
+     * Get full permissions for a specific collection.
+     */
+    getPermissions(slug: string): CollectionPermissions | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollectionAccessService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CollectionAccessService>;
+}
+
+/**
+ * Upload progress state.
+ */
+interface UploadProgress {
+    /** Current status of the upload */
+    status: 'pending' | 'uploading' | 'complete' | 'error';
+    /** Upload progress percentage (0-100) */
+    progress: number;
+    /** Original file being uploaded */
+    file: File;
+    /** Created media document (when complete) */
+    result?: MediaDocument;
+    /** Error message (when error) */
+    error?: string;
+}
+/**
+ * Service for handling file uploads to Momentum CMS.
+ *
+ * @example
+ * ```typescript
+ * const uploadService = inject(UploadService);
+ * uploadService.upload(file).subscribe(progress => {
+ *   console.log(`Progress: ${progress.progress}%`);
+ *   if (progress.status === 'complete') {
+ *     console.log('Uploaded:', progress.result);
+ *   }
+ * });
+ * ```
+ */
+declare class UploadService {
+    private readonly http;
+    private readonly uploadUrl;
+    /** Active uploads signal */
+    private readonly activeUploadsSignal;
+    /** Number of active uploads */
+    readonly activeUploadCount: _angular_core.Signal<number>;
+    /** Whether any uploads are in progress */
+    readonly isUploading: _angular_core.Signal<boolean>;
+    /**
+     * Upload a single file.
+     *
+     * @param file - The file to upload
+     * @param alt - Optional alt text for images
+     * @returns Observable emitting upload progress
+     */
+    upload(file: File, alt?: string): Observable<UploadProgress>;
+    /**
+     * Upload multiple files.
+     *
+     * @param files - Array of files to upload
+     * @returns Array of observables for each file's progress
+     */
+    uploadMultiple(files: File[]): Observable<UploadProgress>[];
+    /**
+     * Get the URL for a media document.
+     *
+     * @param media - Media document or ID
+     * @returns URL to access the file
+     */
+    getMediaUrl(media: MediaDocument | string): string;
+    /**
+     * Update active upload progress.
+     */
+    private updateActiveUpload;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploadService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UploadService>;
+}
+
+/**
+ * Momentum API Service for Angular
+ *
+ * Provides a unified interface for data operations that works seamlessly
+ * in both server-side rendering (SSR) and browser contexts.
+ *
+ * @example
+ * ```typescript
+ * import { injectMomentumAPI } from '@momentumcms/admin';
+ *
+ * @Component({...})
+ * export class PostsComponent {
+ *   private readonly api = injectMomentumAPI();
+ *
+ *   async loadPosts(): Promise<void> {
+ *     const result = await this.api.collection<Post>('posts').find({ limit: 10 });
+ *     this.posts.set(result.docs);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * User context for API operations.
+ */
+interface UserContext {
+    id: string | number;
+    email?: string;
+    role?: string;
+    [key: string]: unknown;
+}
+/**
+ * Context passed to API operations.
+ */
+interface MomentumAPIContext {
+    user?: UserContext;
+    depth?: number;
+    showHiddenFields?: boolean;
+}
+/**
+ * Options for find operations.
+ */
+interface FindOptions {
+    where?: Record<string, unknown>;
+    sort?: string;
+    limit?: number;
+    page?: number;
+    depth?: number;
+    /** Enable TransferState caching for SSR hydration (default: true) */
+    transfer?: boolean;
+    /** Include soft-deleted documents in results. @default false */
+    withDeleted?: boolean;
+    /** Only return soft-deleted documents. @default false */
+    onlyDeleted?: boolean;
+}
+/**
+ * Options for findById operations.
+ */
+interface FindByIdOptions {
+    depth?: number;
+    /** Enable TransferState caching for SSR hydration (default: true) */
+    transfer?: boolean;
+    /** Include soft-deleted documents. @default false */
+    withDeleted?: boolean;
+}
+/**
+ * Result of a find operation with pagination info.
+ */
+interface FindResult<T> {
+    docs: T[];
+    totalDocs: number;
+    totalPages: number;
+    page: number;
+    limit: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    nextPage?: number;
+    prevPage?: number;
+}
+/**
+ * Result of a delete operation.
+ */
+interface DeleteResult {
+    id: string;
+    deleted: boolean;
+}
+/**
+ * Server-side Momentum API instance.
+ * Provided by Express during SSR via provideMomentumAPI().
+ * Must be explicitly provided during SSR - not available in browser.
+ */
+declare const MOMENTUM_API: InjectionToken<MomentumAPIServer>;
+/**
+ * User context for the current request.
+ * Provided by Express during SSR.
+ */
+declare const MOMENTUM_API_CONTEXT: InjectionToken<MomentumAPIContext>;
+/**
+ * Creates providers for Momentum API during SSR.
+ * Use this in your server.ts when calling angularApp.handle().
+ *
+ * @example
+ * ```typescript
+ * import { provideMomentumAPI } from '@momentumcms/admin';
+ *
+ * angularApp.handle(req, {
+ *   providers: provideMomentumAPI(getMomentumAPI(), { user: req.user }),
+ * });
+ * ```
+ */
+declare function provideMomentumAPI(api: MomentumAPIServer, context?: MomentumAPIContext): Provider[];
+/**
+ * Server-side API interface (from @momentumcms/server-core).
+ * This mirrors the MomentumAPI interface for type safety.
+ */
+interface MomentumAPIServer {
+    collection<T = Record<string, unknown>>(slug: string): CollectionOperationsServer<T>;
+    global<T = Record<string, unknown>>(slug: string): GlobalOperationsServer<T>;
+    getConfig(): unknown;
+    setContext(ctx: MomentumAPIContext): MomentumAPIServer;
+    getContext(): MomentumAPIContext;
+}
+/**
+ * Server-side collection operations.
+ */
+interface CollectionOperationsServer<T = Record<string, unknown>> {
+    find(options?: FindOptions): Promise<FindResult<T>>;
+    findById(id: string, options?: {
+        depth?: number;
+        withDeleted?: boolean;
+    }): Promise<T | null>;
+    create(data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    delete(id: string): Promise<DeleteResult>;
+    forceDelete(id: string): Promise<DeleteResult>;
+    restore(id: string): Promise<T>;
+    count(where?: Record<string, unknown>, options?: {
+        withDeleted?: boolean;
+    }): Promise<number>;
+    batchCreate(items: Partial<T>[]): Promise<T[]>;
+    batchUpdate(items: {
+        id: string;
+        data: Partial<T>;
+    }[]): Promise<T[]>;
+    batchDelete(ids: string[]): Promise<DeleteResult[]>;
+}
+/**
+ * Server-side global operations.
+ */
+interface GlobalOperationsServer<T = Record<string, unknown>> {
+    findOne(options?: {
+        depth?: number;
+    }): Promise<T>;
+    update(data: Partial<T>): Promise<T>;
+}
+/**
+ * Client-side global operations (both Observable and Promise).
+ */
+interface MomentumGlobalAPI<T = Record<string, unknown>> {
+    findOne$(options?: {
+        depth?: number;
+    }): Observable<T>;
+    update$(data: Partial<T>): Observable<T>;
+    findOne(options?: {
+        depth?: number;
+    }): Promise<T>;
+    update(data: Partial<T>): Promise<T>;
+}
+/**
+ * Unified client API interface.
+ * Works identically on both server (SSR) and browser.
+ */
+interface MomentumClientAPI {
+    /**
+     * Get operations for a specific collection.
+     */
+    collection<T = Record<string, unknown>>(slug: string): MomentumCollectionAPI<T>;
+    /**
+     * Get operations for a global (singleton document).
+     */
+    global<T = Record<string, unknown>>(slug: string): MomentumGlobalAPI<T>;
+}
+/**
+ * Collection operations with both Observable and Promise methods.
+ */
+interface MomentumCollectionAPI<T = Record<string, unknown>> {
+    find$(options?: FindOptions): Observable<FindResult<T>>;
+    findById$(id: string, options?: FindByIdOptions): Observable<T | null>;
+    create$(data: Partial<T>): Observable<T>;
+    update$(id: string, data: Partial<T>): Observable<T>;
+    delete$(id: string): Observable<DeleteResult>;
+    forceDelete$(id: string): Observable<DeleteResult>;
+    restore$(id: string): Observable<T>;
+    batchCreate$(items: Partial<T>[]): Observable<T[]>;
+    batchUpdate$(items: {
+        id: string;
+        data: Partial<T>;
+    }[]): Observable<T[]>;
+    batchDelete$(ids: string[]): Observable<DeleteResult[]>;
+    find(options?: FindOptions): Promise<FindResult<T>>;
+    findById(id: string, options?: FindByIdOptions): Promise<T | null>;
+    create(data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    delete(id: string): Promise<DeleteResult>;
+    forceDelete(id: string): Promise<DeleteResult>;
+    restore(id: string): Promise<T>;
+    batchCreate(items: Partial<T>[]): Promise<T[]>;
+    batchUpdate(items: {
+        id: string;
+        data: Partial<T>;
+    }[]): Promise<T[]>;
+    batchDelete(ids: string[]): Promise<DeleteResult[]>;
+    findSignal(options?: FindOptions): Signal<FindResult<T> | undefined>;
+    findByIdSignal(id: string, options?: FindByIdOptions): Signal<T | null | undefined>;
+}
+/**
+ * Typed find options with where clause type.
+ */
+interface TypedFindOptions<TWhere> {
+    where?: TWhere;
+    sort?: string;
+    limit?: number;
+    page?: number;
+    depth?: number;
+    /** Enable TransferState caching for SSR hydration */
+    transfer?: boolean;
+}
+/**
+ * Typed findById options.
+ */
+interface TypedFindByIdOptions {
+    depth?: number;
+    /** Enable TransferState caching for SSR hydration */
+    transfer?: boolean;
+    /** Include soft-deleted documents. @default false */
+    withDeleted?: boolean;
+}
+/**
+ * Type-safe collection API with typed where clauses.
+ */
+interface TypedCollectionAPI<TDoc, TWhere = Record<string, unknown>> {
+    find$(options?: TypedFindOptions<TWhere>): Observable<FindResult<TDoc>>;
+    findById$(id: string, options?: TypedFindByIdOptions): Observable<TDoc | null>;
+    create$(data: Partial<TDoc>): Observable<TDoc>;
+    update$(id: string, data: Partial<TDoc>): Observable<TDoc>;
+    delete$(id: string): Observable<DeleteResult>;
+    find(options?: TypedFindOptions<TWhere>): Promise<FindResult<TDoc>>;
+    findById(id: string, options?: TypedFindByIdOptions): Promise<TDoc | null>;
+    create(data: Partial<TDoc>): Promise<TDoc>;
+    update(id: string, data: Partial<TDoc>): Promise<TDoc>;
+    delete(id: string): Promise<DeleteResult>;
+    findSignal(options?: TypedFindOptions<TWhere>): Signal<FindResult<TDoc> | undefined>;
+    findByIdSignal(id: string, options?: TypedFindByIdOptions): Signal<TDoc | null | undefined>;
+}
+/**
+ * Type-safe API interface with direct property access.
+ * Maps collection slugs to typed collection APIs.
+ *
+ * @example
+ * ```typescript
+ * interface TypedMomentumCollections {
+ *   'posts': { doc: Post; where: PostsWhereClause };
+ *   'users': { doc: User; where: UsersWhereClause };
+ * }
+ *
+ * const api = injectTypedMomentumAPI<TypedMomentumCollections>();
+ * const posts = await api.posts.find(); // posts.docs is Post[]
+ * const users = await api.collection('users').find(); // 'users' autocompletes
+ * ```
+ */
+type TypedMomentumClientAPI<TCollections extends {
+    [key: string]: {
+        doc: unknown;
+        where?: unknown;
+    };
+}> = {
+    readonly [K in keyof TCollections]: TypedCollectionAPI<TCollections[K]['doc'], TCollections[K]['where'] extends undefined ? Record<string, unknown> : TCollections[K]['where']>;
+} & {
+    collection<K extends keyof TCollections & string>(slug: K): TypedCollectionAPI<TCollections[K]['doc'], TCollections[K]['where'] extends undefined ? Record<string, unknown> : TCollections[K]['where']>;
+};
+/**
+ * Inject the Momentum API with automatic platform detection.
+ *
+ * - On server (SSR): Uses the direct Momentum API (no HTTP overhead)
+ * - On browser: Uses HTTP calls to the REST API
+ *
+ * @returns The platform-appropriate API implementation
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class PostsComponent {
+ *   private readonly api = injectMomentumAPI();
+ *   readonly posts = signal<Post[]>([]);
+ *
+ *   constructor() {
+ *     // Using observables
+ *     this.api.collection<Post>('posts').find$().subscribe(result => {
+ *       this.posts.set(result.docs);
+ *     });
+ *
+ *     // Or using promises
+ *     this.loadPosts();
+ *   }
+ *
+ *   async loadPosts(): Promise<void> {
+ *     const result = await this.api.collection<Post>('posts').find({ limit: 10 });
+ *     this.posts.set(result.docs);
+ *   }
+ * }
+ * ```
+ */
+declare function injectMomentumAPI(): MomentumClientAPI;
+/**
+ * Inject a type-safe Momentum API with full intellisense for collections.
+ *
+ * @example
+ * ```typescript
+ * // First, generate types or define them manually
+ * interface TypedMomentumCollections {
+ *   'posts': { doc: Post; where: PostsWhereClause };
+ *   'users': { doc: User; where: UsersWhereClause };
+ * }
+ *
+ * // Then inject the typed API
+ * const api = injectTypedMomentumAPI<TypedMomentumCollections>();
+ *
+ * // Use with full type safety
+ * const posts = await api.posts.find(); // posts.docs is Post[]
+ * const users = await api.collection('users').find(); // 'users' autocompletes
+ *
+ * // Typed where clauses
+ * const published = await api.posts.find({
+ *   where: { status: 'published' } // type-checked
+ * });
+ * ```
+ */
+declare function injectTypedMomentumAPI<TCollections extends {
+    [key: string]: {
+        doc: unknown;
+        where?: unknown;
+    };
+}>(): TypedMomentumClientAPI<TCollections>;
+
+/**
+ * Widget Types for Momentum CMS Admin
+ *
+ * Common types used across admin widgets.
+ */
+
+/**
+ * Branding configuration for admin sidebar.
+ */
+interface AdminBranding {
+    /** The title displayed in the sidebar header */
+    title?: string;
+    /** URL to the logo image */
+    logo?: string;
+}
+/**
+ * Navigation item in the admin sidebar.
+ */
+interface AdminNavItem {
+    /** Display label */
+    label: string;
+    /** Router link path */
+    href: string;
+    /** Icon name (for future icon support) */
+    icon?: string;
+    /** Badge content (count or text) */
+    badge?: string | number;
+    /** Whether this item is active */
+    active?: boolean;
+    /** Whether this item is disabled */
+    disabled?: boolean;
+}
+/**
+ * Navigation section with optional grouping.
+ */
+interface AdminNavSection {
+    /** Section title (optional) */
+    title?: string;
+    /** Navigation items in this section */
+    items: AdminNavItem[];
+    /** Whether the section is collapsible */
+    collapsible?: boolean;
+    /** Whether the section is expanded (if collapsible) */
+    expanded?: boolean;
+}
+/**
+ * User information for the sidebar user section.
+ */
+interface AdminUser {
+    /** User's unique ID */
+    id: string | number;
+    /** User's full name */
+    name: string;
+    /** User's email */
+    email: string;
+    /** User's avatar URL (optional) */
+    avatarUrl?: string;
+    /** User's role (optional) */
+    role?: string;
+}
+/**
+ * Collection with count information for the dashboard.
+ */
+interface CollectionWithCount {
+    /** Collection configuration */
+    collection: CollectionConfig;
+    /** Number of documents in the collection */
+    count: number;
+    /** Whether the count is loading */
+    loading?: boolean;
+    /** Error message if count fetch failed */
+    error?: string;
+}
+/**
+ * Action that can be performed on an entity.
+ */
+interface EntityAction {
+    /** Unique action identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Icon name (for future icon support) */
+    icon?: string;
+    /** Variant for styling (default, destructive) */
+    variant?: 'default' | 'destructive';
+    /** Whether action is disabled */
+    disabled?: boolean;
+    /** Whether action requires confirmation */
+    requiresConfirmation?: boolean;
+    /** Confirmation message (if requiresConfirmation is true) */
+    confirmationMessage?: string;
+}
+/**
+ * Generic entity record from the API.
+ */
+interface Entity {
+    id: string | number;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Result emitted when the entity sheet closes.
+ */
+interface EntitySheetResult {
+    /** What happened in the sheet */
+    action: 'created' | 'updated' | 'deleted' | 'cancelled';
+    /** The entity that was created or updated (undefined on cancel) */
+    entity?: Entity;
+    /** The collection slug */
+    collection: string;
+}
+/** Query parameter keys used by the entity sheet */
+declare const SHEET_QUERY_PARAMS: {
+    collection: string;
+    entityId: string;
+    mode: string;
+    callback: string;
+};
+/**
+ * Service for opening/closing the entity sheet via query parameters.
+ *
+ * The sheet is rendered directly in the AdminShell (no named router outlet).
+ * Query parameters carry the state: `sheetCollection`, `sheetEntityId`, `sheetMode`, `sheetCallback`.
+ * This approach keeps the URL clean and SSR-friendly (no auxiliary route parentheses).
+ *
+ * Usage:
+ * ```typescript
+ * const sheetService = inject(EntitySheetService);
+ *
+ * sheetService.openCreate('authors').subscribe((result) => {
+ *   if (result.action === 'created') {
+ *     console.log('Created:', result.entity);
+ *   }
+ * });
+ * ```
+ */
+declare class EntitySheetService {
+    private readonly router;
+    private readonly destroyRef;
+    private readonly document;
+    /** Pending callback subjects keyed by callback ID */
+    private readonly pendingCallbacks;
+    /** Handle for the close animation timer (for cancellation on rapid open/close) */
+    private closeTimerId;
+    /** Element that had focus when the sheet was opened (for focus restoration) */
+    private triggerElement;
+    /** Whether the sheet is currently open */
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Whether the sheet is playing its close animation */
+    readonly isClosing: _angular_core.WritableSignal<boolean>;
+    /** Whether the sheet DOM should be present (open or animating closed) */
+    readonly isVisible: _angular_core.Signal<boolean>;
+    /**
+     * Open the entity sheet to create a new entity.
+     */
+    openCreate(collection: string): Observable<EntitySheetResult>;
+    /**
+     * Open the entity sheet to edit an existing entity.
+     */
+    openEdit(collection: string, entityId: string): Observable<EntitySheetResult>;
+    /**
+     * Open the entity sheet to view an existing entity.
+     */
+    openView(collection: string, entityId: string): Observable<EntitySheetResult>;
+    /**
+     * Close the sheet with a slide-out animation, then emit the result to any pending callback.
+     */
+    close(result?: EntitySheetResult): void;
+    /**
+     * Restore sheet state from query params and sync on navigation.
+     * Handles page refresh and browser back/forward.
+     * Called by AdminShellComponent on browser init.
+     */
+    initFromQueryParams(): void;
+    private syncIsOpenFromUrl;
+    private openSheet;
+    private cancelCloseAnimation;
+    /** Complete and remove all pending callback subjects (prevents memory leaks) */
+    private cleanupAllPendingCallbacks;
+    /** Return focus to the element that triggered the sheet open */
+    private restoreFocus;
+    private getCurrentCallbackId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySheetService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EntitySheetService>;
+}
+
+/**
+ * Document status for versioned collections.
+ */
+type DocumentStatus = 'draft' | 'published';
+/**
+ * Version query options.
+ */
+interface VersionFindOptions {
+    limit?: number;
+    page?: number;
+    includeAutosave?: boolean;
+    status?: DocumentStatus;
+}
+/**
+ * Parsed document version with typed data.
+ */
+interface DocumentVersionParsed<T = Record<string, unknown>> {
+    id: string;
+    parent: string;
+    version: T;
+    _status: DocumentStatus;
+    autosave: boolean;
+    publishedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Result of a version query with pagination.
+ */
+interface VersionQueryResult<T = Record<string, unknown>> {
+    docs: DocumentVersionParsed<T>[];
+    totalDocs: number;
+    totalPages: number;
+    page: number;
+    limit: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+/**
+ * Options for restoring a version.
+ */
+interface RestoreVersionOptions {
+    versionId: string;
+    publish?: boolean;
+}
+/**
+ * Result of a restore operation.
+ */
+interface RestoreResult<T = Record<string, unknown>> {
+    doc: T;
+    message: string;
+}
+/**
+ * Result of a publish/unpublish operation.
+ */
+interface PublishResult<T = Record<string, unknown>> {
+    doc: T;
+    message: string;
+}
+/**
+ * Result of a draft save operation.
+ */
+interface DraftSaveResult<T = Record<string, unknown>> {
+    version: DocumentVersionParsed<T>;
+    message: string;
+}
+/**
+ * Result of a status query.
+ */
+interface StatusResult {
+    status: DocumentStatus;
+}
+/**
+ * A single field difference between two versions.
+ */
+interface VersionFieldDiff {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+/**
+ * Service for managing document versions in the admin UI.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class VersionHistoryComponent {
+ *   private readonly versionService = inject(VersionService);
+ *
+ *   readonly versions = signal<DocumentVersionParsed[]>([]);
+ *   readonly isLoading = signal(false);
+ *
+ *   async loadVersions(collection: string, docId: string): Promise<void> {
+ *     this.isLoading.set(true);
+ *     const result = await this.versionService.findVersions(collection, docId);
+ *     this.versions.set(result.docs);
+ *     this.isLoading.set(false);
+ *   }
+ * }
+ * ```
+ */
+declare class VersionService {
+    private readonly http;
+    /** Loading state signal */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Error state signal */
+    readonly error: _angular_core.WritableSignal<string | null>;
+    /** Last saved timestamp signal */
+    readonly lastSaved: _angular_core.WritableSignal<Date | null>;
+    /**
+     * Find all versions for a document.
+     */
+    findVersions$<T = Record<string, unknown>>(collection: string, docId: string, options?: VersionFindOptions): Observable<VersionQueryResult<T>>;
+    /**
+     * Find all versions for a document (Promise version).
+     */
+    findVersions<T = Record<string, unknown>>(collection: string, docId: string, options?: VersionFindOptions): Promise<VersionQueryResult<T>>;
+    /**
+     * Find a specific version by ID.
+     */
+    findVersionById$<T = Record<string, unknown>>(collection: string, docId: string, versionId: string): Observable<DocumentVersionParsed<T>>;
+    /**
+     * Find a specific version by ID (Promise version).
+     */
+    findVersionById<T = Record<string, unknown>>(collection: string, docId: string, versionId: string): Promise<DocumentVersionParsed<T>>;
+    /**
+     * Restore a document to a previous version.
+     */
+    restore$<T = Record<string, unknown>>(collection: string, docId: string, options: RestoreVersionOptions): Observable<RestoreResult<T>>;
+    /**
+     * Restore a document to a previous version (Promise version).
+     */
+    restore<T = Record<string, unknown>>(collection: string, docId: string, options: RestoreVersionOptions): Promise<RestoreResult<T>>;
+    /**
+     * Publish a document.
+     */
+    publish$<T = Record<string, unknown>>(collection: string, docId: string): Observable<PublishResult<T>>;
+    /**
+     * Publish a document (Promise version).
+     */
+    publish<T = Record<string, unknown>>(collection: string, docId: string): Promise<PublishResult<T>>;
+    /**
+     * Unpublish a document.
+     */
+    unpublish$<T = Record<string, unknown>>(collection: string, docId: string): Observable<PublishResult<T>>;
+    /**
+     * Unpublish a document (Promise version).
+     */
+    unpublish<T = Record<string, unknown>>(collection: string, docId: string): Promise<PublishResult<T>>;
+    /**
+     * Save a draft version (autosave).
+     */
+    saveDraft$<T = Record<string, unknown>>(collection: string, docId: string, data: Partial<T>): Observable<DraftSaveResult<T>>;
+    /**
+     * Save a draft version (Promise version).
+     */
+    saveDraft<T = Record<string, unknown>>(collection: string, docId: string, data: Partial<T>): Promise<DraftSaveResult<T>>;
+    /**
+     * Get the current status of a document.
+     */
+    getStatus$(collection: string, docId: string): Observable<DocumentStatus>;
+    /**
+     * Get the current status of a document (Promise version).
+     */
+    getStatus(collection: string, docId: string): Promise<DocumentStatus>;
+    /**
+     * Compare two versions and return field-level differences.
+     */
+    compareVersions$(collection: string, docId: string, versionId1: string, versionId2: string): Observable<VersionFieldDiff[]>;
+    /**
+     * Compare two versions and return field-level differences (Promise version).
+     */
+    compareVersions(collection: string, docId: string, versionId1: string, versionId2: string): Promise<VersionFieldDiff[]>;
+    /**
+     * Build the API URL for version operations.
+     */
+    private buildUrl;
+    /**
+     * Build query params from options.
+     */
+    private buildParams;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VersionService>;
+}
+/**
+ * Inject the Version Service.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class VersionHistoryComponent {
+ *   private readonly versionService = injectVersionService();
+ *
+ *   async restoreVersion(versionId: string): Promise<void> {
+ *     await this.versionService.restore(this.collection, this.docId, {
+ *       versionId,
+ *       publish: false,
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare function injectVersionService(): VersionService;
+
+/**
+ * Auth guard that protects routes requiring authentication.
+ *
+ * Redirects to:
+ * - /admin/setup if no users exist (first-time setup)
+ * - /admin/login if user is not authenticated
+ *
+ * During SSR, the guard allows access and defers redirect decisions to
+ * client-side hydration. The session resolver middleware provides user
+ * context for SSR rendering via MOMENTUM_API_CONTEXT/injectUser(), but
+ * guards return true during SSR to avoid hydration conflicts.
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'dashboard',
+ *     component: DashboardPage,
+ *     canActivate: [authGuard],
+ *   },
+ * ];
+ * ```
+ */
+declare const authGuard: CanActivateFn;
+/**
+ * Admin guard that requires admin role.
+ *
+ * Redirects to:
+ * - /admin/setup if no users exist
+ * - /admin/login if user is not authenticated
+ * - /admin if user is not an admin
+ *
+ * During SSR, the guard allows access and defers redirect decisions to
+ * client-side hydration to avoid hydration conflicts.
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'settings',
+ *     component: SettingsPage,
+ *     canActivate: [adminGuard],
+ *   },
+ * ];
+ * ```
+ */
+declare const adminGuard: CanActivateFn;
+
+/**
+ * Guest guard that allows access only to unauthenticated users.
+ *
+ * Redirects to:
+ * - /admin/setup if no users exist (first-time setup)
+ * - /admin if user is already authenticated
+ *
+ * During SSR, the guard allows access and defers redirect decisions to
+ * client-side hydration to avoid hydration conflicts.
+ *
+ * Use this guard for login/register pages.
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'login',
+ *     component: LoginPage,
+ *     canActivate: [guestGuard],
+ *   },
+ * ];
+ * ```
+ */
+declare const guestGuard: CanActivateFn;
+
+/**
+ * Setup guard that allows access only when no users exist.
+ *
+ * Redirects to:
+ * - /admin/login if users already exist
+ *
+ * During SSR, the guard allows access and defers redirect decisions to
+ * client-side hydration to avoid hydration conflicts.
+ *
+ * Use this guard for the initial setup/first user creation page.
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'setup',
+ *     component: SetupPage,
+ *     canActivate: [setupGuard],
+ *   },
+ * ];
+ * ```
+ */
+declare const setupGuard: CanActivateFn;
+
+/**
+ * Collection access guard that checks if the user can access a specific collection.
+ *
+ * This guard should be used on routes that have a :slug parameter in the path.
+ * It checks the collection-level `admin` access function to determine if the
+ * user is allowed to view the collection in the admin panel.
+ *
+ * Redirects to:
+ * - /admin/setup if no users exist
+ * - /admin/login if user is not authenticated
+ * - /admin if user cannot access the collection
+ *
+ * Note: During SSR, the guard allows access and defers checks to client-side
+ * hydration. This is necessary because SSR doesn't have access to browser cookies.
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'collections/:slug',
+ *     component: CollectionListPage,
+ *     canActivate: [authGuard, collectionAccessGuard],
+ *   },
+ * ];
+ * ```
+ */
+declare const collectionAccessGuard: CanActivateFn;
+
+/**
+ * Interface for components that track unsaved changes.
+ */
+interface HasUnsavedChanges {
+    hasUnsavedChanges(): boolean;
+}
+/**
+ * Route guard that prompts the user before navigating away from a dirty form.
+ */
+declare const unsavedChangesGuard: CanDeactivateFn<HasUnsavedChanges>;
+
+/**
+ * Theme options for the admin UI.
+ */
+type McmsTheme = 'light' | 'dark' | 'system';
+/**
+ * Theme service for Momentum CMS Admin UI.
+ *
+ * Provides reactive theme state with system preference detection,
+ * localStorage persistence, and dark mode toggle.
+ *
+ * Usage:
+ * ```typescript
+ * @Component({...})
+ * export class MyComponent {
+ *   private readonly theme = inject(McmsThemeService);
+ *
+ *   toggleDarkMode(): void {
+ *     this.theme.toggleTheme();
+ *   }
+ * }
+ * ```
+ */
+declare class McmsThemeService {
+    private readonly platformId;
+    private readonly document;
+    private readonly isBrowser;
+    /**
+     * Current theme setting (light, dark, or system).
+     */
+    readonly theme: _angular_core.WritableSignal<McmsTheme>;
+    /**
+     * Resolved theme after applying system preference.
+     * Always returns either 'light' or 'dark'.
+     */
+    readonly resolvedTheme: _angular_core.Signal<"light" | "dark">;
+    /**
+     * Whether the resolved theme is dark.
+     */
+    readonly isDark: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Sets the theme and persists to localStorage.
+     */
+    setTheme(theme: McmsTheme): void;
+    /**
+     * Toggles between light and dark themes.
+     * If currently on system, uses the resolved preference as starting point.
+     */
+    toggleTheme(): void;
+    /**
+     * Loads theme from localStorage or defaults to 'system'.
+     */
+    private loadTheme;
+    /**
+     * Gets the system color scheme preference.
+     */
+    private getSystemPreference;
+    /**
+     * Applies theme class to document element.
+     */
+    private applyThemeToDOM;
+    /**
+     * Listens for system preference changes when theme is set to 'system'.
+     */
+    private listenForSystemPreferenceChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<McmsThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<McmsThemeService>;
+}
+
+/**
+ * User Injection Utilities for Momentum CMS
+ *
+ * Provides type-safe access to the current authenticated user in both
+ * SSR and browser contexts using Angular signals.
+ *
+ * @example
+ * ```typescript
+ * import type { Users } from './types/momentum.generated';
+ * import { injectUser } from '@momentumcms/admin';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   // Typed user from your generated types
+ *   readonly user = injectUser<Users>();
+ *
+ *   // Or use convenience functions
+ *   readonly isAdmin = injectIsAdmin();
+ *   readonly isAuthenticated = injectIsAuthenticated();
+ * }
+ * ```
+ */
+
+/**
+ * Base user type that all user types must extend.
+ * Matches the common fields between Better Auth users and Momentum collection users.
+ */
+interface BaseUser {
+    id: string | number;
+    email?: string;
+    role?: string;
+}
+/**
+ * Inject the current authenticated user with proper typing.
+ *
+ * Works seamlessly in both SSR and browser contexts:
+ * - **SSR**: Returns user from `MOMENTUM_API_CONTEXT` (set by session resolver middleware)
+ * - **Browser**: Returns user from `MomentumAuthService` (fetched via /api/auth/get-session)
+ *
+ * The generic type parameter allows you to use your generated collection types
+ * for full type safety with your user schema.
+ *
+ * @typeParam T - User type extending UserContext (use your generated Users type)
+ * @returns Signal containing the current user or null if not authenticated
+ *
+ * @example
+ * ```typescript
+ * import type { Users } from './types/momentum.generated';
+ *
+ * @Component({...})
+ * export class ProfileComponent {
+ *   readonly user = injectUser<Users>();
+ *
+ *   constructor() {
+ *     effect(() => {
+ *       const currentUser = this.user();
+ *       if (currentUser) {
+ *         console.log('Role:', currentUser.role); // Typed!
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare function injectUser<T extends BaseUser = AuthUser>(): Signal<T | null>;
+/**
+ * Inject the current user's role.
+ *
+ * Convenience wrapper that returns just the role string.
+ *
+ * @returns Signal containing the user's role or null if not authenticated
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class NavComponent {
+ *   readonly role = injectUserRole();
+ *
+ *   canEdit = computed(() => {
+ *     const r = this.role();
+ *     return r === 'admin' || r === 'editor';
+ *   });
+ * }
+ * ```
+ */
+declare function injectUserRole(): Signal<string | null>;
+/**
+ * Inject whether the current user is authenticated.
+ *
+ * @returns Signal containing true if user is authenticated, false otherwise
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (isAuthenticated()) {
+ *       <user-menu />
+ *     } @else {
+ *       <login-button />
+ *     }
+ *   `
+ * })
+ * export class HeaderComponent {
+ *   readonly isAuthenticated = injectIsAuthenticated();
+ * }
+ * ```
+ */
+declare function injectIsAuthenticated(): Signal<boolean>;
+/**
+ * Inject whether the current user is an admin.
+ *
+ * @returns Signal containing true if user has admin role, false otherwise
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (isAdmin()) {
+ *       <admin-settings />
+ *     }
+ *   `
+ * })
+ * export class SettingsComponent {
+ *   readonly isAdmin = injectIsAdmin();
+ * }
+ * ```
+ */
+declare function injectIsAdmin(): Signal<boolean>;
+/**
+ * Inject whether the current user has a specific role.
+ *
+ * @param role - The role to check for
+ * @returns Signal containing true if user has the specified role
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class EditorComponent {
+ *   readonly canEdit = injectHasRole('editor');
+ * }
+ * ```
+ */
+declare function injectHasRole(role: string): Signal<boolean>;
+/**
+ * Inject whether the current user has any of the specified roles.
+ *
+ * @param roles - Array of roles to check
+ * @returns Signal containing true if user has any of the specified roles
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class ContentComponent {
+ *   readonly canManageContent = injectHasAnyRole(['admin', 'editor']);
+ * }
+ * ```
+ */
+declare function injectHasAnyRole(roles: string[]): Signal<boolean>;
+
+/**
+ * Admin Shell Component
+ *
+ * The main layout component for the admin UI.
+ * Provides navigation sidebar and content area.
+ *
+ * Features:
+ * - Responsive sidebar (drawer on mobile, static on desktop)
+ * - Keyboard shortcuts (Cmd+B / Ctrl+B to toggle sidebar)
+ * - Mobile header with hamburger menu
+ * - Entity sheet for inline entity create/edit/view (driven by query params)
+ */
+declare class AdminShellComponent implements OnInit {
+    private readonly route;
+    private readonly router;
+    private readonly platformId;
+    private readonly auth;
+    private readonly collectionAccess;
+    private readonly sidebar;
+    readonly entitySheet: EntitySheetService;
+    /** All collections from route data */
+    private readonly allCollections;
+    /** Collections filtered by access permissions and visibility */
+    readonly collections: _angular_core.Signal<CollectionConfig[]>;
+    /** Globals from route data */
+    readonly globals: _angular_core.Signal<GlobalConfig[]>;
+    /** Plugin routes from route data */
+    readonly pluginRoutes: _angular_core.Signal<AdminPluginRoute[]>;
+    /** Branding for sidebar */
+    readonly sidebarBranding: _angular_core.Signal<AdminBranding | undefined>;
+    /** SSR-aware user signal (reads from MOMENTUM_API_CONTEXT during SSR, auth service in browser) */
+    private readonly currentUser;
+    /** User for sidebar */
+    readonly sidebarUser: _angular_core.Signal<AdminUser | null>;
+    ngOnInit(): void;
+    /** Close the sheet when the Escape key is pressed */
+    onEscapeKey(): void;
+    /** Close the sheet when the backdrop is clicked */
+    onSheetBackdropClick(): void;
+    private initializeAuth;
+    onSignOut(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdminShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AdminShellComponent, "mcms-admin-shell", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Forgot Password Form Component
+ *
+ * A reusable form for requesting password reset emails.
+ * Can be embedded in any layout or used with the ForgotPasswordPage wrapper.
+ *
+ * @example
+ * ```html
+ * <mcms-forgot-password-form
+ *   (resetRequested)="onResetRequested($event)"
+ *   (backToLogin)="navigateToLogin()"
+ * />
+ * ```
+ */
+declare class ForgotPasswordFormComponent {
+    private readonly auth;
+    /** Emitted when reset email has been requested */
+    readonly resetRequested: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when user wants to go back to login */
+    readonly backToLogin: _angular_core.OutputEmitterRef<void>;
+    /** Whether the component has been hydrated (SSR → client transition complete) */
+    readonly hydrated: _angular_core.WritableSignal<boolean>;
+    constructor();
+    readonly email: _angular_core.WritableSignal<string>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly isSubmitting: _angular_core.WritableSignal<boolean>;
+    readonly submitted: _angular_core.WritableSignal<boolean>;
+    readonly touched: _angular_core.WritableSignal<boolean>;
+    readonly emailErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly isValid: _angular_core.Signal<boolean>;
+    onSubmit(event: Event): Promise<void>;
+    onBackToLogin(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForgotPasswordFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForgotPasswordFormComponent, "mcms-forgot-password-form", never, {}, { "resetRequested": "resetRequested"; "backToLogin": "backToLogin"; }, never, never, true, never>;
+}
+
+/**
+ * Reset Password Form Component
+ *
+ * A reusable form for resetting password with a token.
+ * Can be embedded in any layout or used with the ResetPasswordPage wrapper.
+ *
+ * @example
+ * ```html
+ * <mcms-reset-password-form
+ *   [token]="tokenFromUrl"
+ *   (resetComplete)="onResetComplete()"
+ *   (resetFailed)="onResetFailed($event)"
+ * />
+ * ```
+ */
+declare class ResetPasswordFormComponent {
+    private readonly auth;
+    /** Whether the component has been hydrated (SSR → client transition complete) */
+    readonly hydrated: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** The reset token from the URL */
+    readonly token: _angular_core.InputSignal<string>;
+    /** Emitted when password reset is complete */
+    readonly resetComplete: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when password reset fails */
+    readonly resetFailed: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when user wants to go to login */
+    readonly goToLogin: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when user wants to request a new reset link */
+    readonly goToForgotPassword: _angular_core.OutputEmitterRef<void>;
+    readonly password: _angular_core.WritableSignal<string>;
+    readonly confirmPassword: _angular_core.WritableSignal<string>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly isSubmitting: _angular_core.WritableSignal<boolean>;
+    readonly resetSuccess: _angular_core.WritableSignal<boolean>;
+    readonly touched: _angular_core.WritableSignal<boolean>;
+    readonly passwordErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly confirmPasswordErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly isValid: _angular_core.Signal<boolean>;
+    onSubmit(event: Event): Promise<void>;
+    onGoToLogin(): void;
+    onGoToForgotPassword(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResetPasswordFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResetPasswordFormComponent, "mcms-reset-password-form", never, { "token": { "alias": "token"; "required": false; "isSignal": true; }; }, { "resetComplete": "resetComplete"; "resetFailed": "resetFailed"; "goToLogin": "goToLogin"; "goToForgotPassword": "goToForgotPassword"; }, never, never, true, never>;
+}
+
+/**
+ * Dashboard Page Component
+ *
+ * The main dashboard showing an overview of all collections.
+ */
+declare class DashboardPage {
+    private readonly route;
+    private readonly collectionAccess;
+    readonly basePath = "/admin/collections";
+    /** All collections from route data (unfiltered) */
+    private readonly allCollections;
+    /** Collections filtered by visibility and access permissions */
+    readonly collections: _angular_core.Signal<CollectionConfig[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardPage, "mcms-dashboard", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Entity List Widget Types
+ *
+ * Types for the entity list widget that displays collection data.
+ */
+
+/**
+ * Column configuration for entity list.
+ * Extends DataTableColumn with collection-specific options.
+ */
+interface EntityListColumn<T = Entity> extends DataTableColumn<T> {
+    /** Field type for automatic formatting */
+    type?: 'text' | 'number' | 'date' | 'datetime' | 'boolean' | 'badge' | 'relationship' | 'array' | 'group' | 'json';
+    /** Badge variant for 'badge' type columns */
+    badgeVariant?: 'default' | 'secondary' | 'destructive' | 'outline';
+    /** Badge color mapping for 'badge' type columns */
+    badgeMap?: Record<string, {
+        label: string;
+        variant: 'default' | 'secondary' | 'destructive' | 'outline';
+    }>;
+}
+/**
+ * Event emitted when an entity action is triggered.
+ */
+interface EntityListActionEvent<T = Entity> {
+    /** The action that was triggered */
+    action: EntityAction;
+    /** The entity the action was triggered on */
+    entity: T;
+}
+/**
+ * Event emitted when a bulk action is triggered.
+ */
+interface EntityListBulkActionEvent<T = Entity> {
+    /** The action that was triggered */
+    action: EntityAction;
+    /** The entities the action was triggered on */
+    entities: T[];
+}
+/**
+ * Result of a find operation.
+ */
+interface EntityListFindResult<T = Entity> {
+    docs: T[];
+    totalDocs: number;
+    totalPages: number;
+    page: number;
+    limit: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+
+/**
+ * Entity List Widget
+ *
+ * Displays a collection's data in a data table with search, sorting,
+ * pagination, and actions. Connects to Momentum API for data fetching.
+ *
+ * @example
+ * ```html
+ * <mcms-entity-list
+ *   [collection]="postsCollection"
+ *   basePath="/admin/collections"
+ *   (entityClick)="onEntityClick($event)"
+ * />
+ * ```
+ */
+declare class EntityListWidget<T extends Entity = Entity> {
+    private readonly api;
+    private readonly collectionAccess;
+    private readonly feedback;
+    private readonly dialog;
+    private readonly router;
+    private readonly route;
+    /** Template ref for complex cell rendering (group, array, json). */
+    private readonly complexCellTemplate;
+    /** The collection configuration */
+    readonly collection: _angular_core.InputSignal<CollectionConfig>;
+    /** Base path for entity routes */
+    readonly basePath: _angular_core.InputSignal<string>;
+    /** Whether to show the header with title and create button */
+    readonly showHeader: _angular_core.InputSignal<boolean>;
+    /** Whether to show breadcrumbs */
+    readonly showBreadcrumbs: _angular_core.InputSignal<boolean>;
+    /** Custom columns (auto-derived from collection if not provided) */
+    readonly columns: _angular_core.InputSignal<EntityListColumn<T>[]>;
+    /** Row actions for each entity */
+    readonly rowActions: _angular_core.InputSignal<EntityAction[]>;
+    /** Bulk actions for selected entities */
+    readonly bulkActions: _angular_core.InputSignal<EntityAction[]>;
+    /** Custom action buttons displayed in the collection list header */
+    readonly headerActions: _angular_core.InputSignal<{
+        id: string;
+        label: string;
+        endpoint?: string;
+    }[]>;
+    /** Emitted when a header action button is clicked */
+    readonly headerActionClick: _angular_core.OutputEmitterRef<{
+        id: string;
+        label: string;
+        endpoint?: string;
+    }>;
+    /** Whether the table is searchable */
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    /** Search placeholder */
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    /** Fields to search in (auto-derived if not provided) */
+    readonly searchFields: _angular_core.InputSignal<string[]>;
+    /** Whether the table is sortable */
+    readonly sortable: _angular_core.InputSignal<boolean>;
+    /** Whether the table is selectable */
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    /** Whether the table is paginated */
+    readonly paginated: _angular_core.InputSignal<boolean>;
+    /** Default page size */
+    readonly pageSize: _angular_core.InputSignal<number>;
+    /** Empty state title */
+    readonly emptyTitle: _angular_core.InputSignal<string>;
+    /** Empty state description */
+    readonly emptyDescription: _angular_core.InputSignal<string>;
+    /** Outputs */
+    readonly entityClick: _angular_core.OutputEmitterRef<T>;
+    readonly entityAction: _angular_core.OutputEmitterRef<EntityListActionEvent<T>>;
+    readonly bulkAction: _angular_core.OutputEmitterRef<EntityListBulkActionEvent<T>>;
+    readonly dataLoaded: _angular_core.OutputEmitterRef<FindResult<T>>;
+    /** Internal state */
+    readonly entities: _angular_core.WritableSignal<T[]>;
+    readonly totalItems: _angular_core.WritableSignal<number>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    readonly sort: _angular_core.WritableSignal<DataTableSort<T> | undefined>;
+    readonly selectedEntities: _angular_core.WritableSignal<T[]>;
+    readonly searchQuery: _angular_core.ModelSignal<string>;
+    readonly viewingTrash: _angular_core.WritableSignal<boolean>;
+    /** Whether the collection has soft delete enabled */
+    readonly hasSoftDelete: _angular_core.Signal<boolean>;
+    /** Computed collection label */
+    readonly collectionLabel: _angular_core.Signal<string>;
+    /** Computed collection label singular */
+    readonly collectionLabelSingular: _angular_core.Signal<string>;
+    /** Dashboard path (remove /collections from base path) */
+    readonly dashboardPath: _angular_core.Signal<string>;
+    /** Auto-derive columns from collection fields if not provided */
+    readonly tableColumns: _angular_core.Signal<EntityListColumn<T>[]>;
+    /** Convert row actions to DataTable format */
+    readonly tableRowActions: _angular_core.Signal<DataTableRowAction<T>[]>;
+    /** Track entities by ID */
+    readonly trackById: (item: T) => string | number;
+    /** Can user create entities */
+    readonly canCreate: _angular_core.Signal<boolean>;
+    /** Can user delete entities */
+    readonly canDelete: _angular_core.Signal<boolean>;
+    private previousCollectionSlug;
+    constructor();
+    /**
+     * Load data from API.
+     */
+    private loadData;
+    /**
+     * Get default search fields from collection.
+     */
+    private getDefaultSearchFields;
+    /**
+     * Determine if a field should be shown in the list.
+     */
+    private shouldShowFieldInList;
+    /**
+     * Convert a collection field to a table column.
+     */
+    private fieldToColumn;
+    /**
+     * Format a value based on its type.
+     */
+    private formatValue;
+    /**
+     * Generate a brief summary string for complex field values (group, array, json).
+     */
+    getComplexSummary(value: unknown, type?: string): string;
+    /**
+     * Open a dialog to preview the full data for a complex field.
+     */
+    openDataPreview(value: unknown, fieldName: string | number | symbol): void;
+    /**
+     * Handle row click.
+     */
+    onRowClick(entity: T): void;
+    /**
+     * Handle row action.
+     */
+    onRowAction(event: DataTableRowActionEvent<T>): void;
+    /**
+     * Handle bulk action.
+     */
+    onBulkAction(action: EntityAction): Promise<void>;
+    /**
+     * Handle search change.
+     */
+    onSearchChange(query: string): void;
+    /**
+     * Handle page change.
+     */
+    onPageChange(page: number): void;
+    /**
+     * Handle sort change.
+     */
+    onSortChange(sortState: DataTableSort<T> | undefined): void;
+    /**
+     * Reload data.
+     */
+    reload(): void;
+    /**
+     * Toggle between active and trash views.
+     */
+    toggleTrashView(): void;
+    /**
+     * Handle create button click.
+     */
+    onCreateClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityListWidget<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityListWidget<any>, "mcms-entity-list", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "rowActions": { "alias": "rowActions"; "required": false; "isSignal": true; }; "bulkActions": { "alias": "bulkActions"; "required": false; "isSignal": true; }; "headerActions": { "alias": "headerActions"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "searchFields": { "alias": "searchFields"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "paginated": { "alias": "paginated"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "emptyTitle": { "alias": "emptyTitle"; "required": false; "isSignal": true; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; }, { "headerActionClick": "headerActionClick"; "entityClick": "entityClick"; "entityAction": "entityAction"; "bulkAction": "bulkAction"; "dataLoaded": "dataLoaded"; "searchQuery": "searchQueryChange"; }, never, never, true, never>;
+}
+
+/**
+ * Collection List Page Component
+ *
+ * Displays a list of documents in a collection using the EntityListWidget.
+ * Supports bulk actions (e.g., bulk delete) via selection checkboxes.
+ */
+declare class CollectionListPage {
+    private readonly route;
+    private readonly router;
+    private readonly api;
+    private readonly feedback;
+    private readonly dialog;
+    readonly entityList: _angular_core.Signal<EntityListWidget<Entity> | undefined>;
+    readonly basePath = "/admin/collections";
+    private readonly slug;
+    readonly collection: _angular_core.Signal<CollectionConfig | undefined>;
+    readonly headerActions: _angular_core.Signal<{
+        id: string;
+        label: string;
+        endpoint?: string;
+    }[]>;
+    readonly bulkActions: _angular_core.Signal<EntityAction[]>;
+    onEntityClick(entity: Entity): void;
+    onHeaderAction(action: NonNullable<AdminConfig['headerActions']>[number]): void;
+    onBulkAction(event: EntityListBulkActionEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollectionListPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollectionListPage, "mcms-collection-list", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Collection View Page Component
+ *
+ * Displays a read-only view of a document using the EntityViewWidget.
+ * When preview is enabled, shows a toggleable live preview panel.
+ */
+declare class CollectionViewPage {
+    private readonly route;
+    private readonly router;
+    readonly basePath = "/admin/collections";
+    /** Whether the live preview panel is visible */
+    readonly showPreview: _angular_core.WritableSignal<boolean>;
+    /** Reference to the entity view widget to read its entity data */
+    private readonly entityViewRef;
+    private readonly slug;
+    readonly entityId: _angular_core.Signal<string>;
+    readonly collection: _angular_core.Signal<CollectionConfig | undefined>;
+    /** Preview config from collection admin settings */
+    readonly previewConfig: _angular_core.Signal<boolean | ((doc: Record<string, unknown>) => string) | undefined>;
+    /** Entity data from the entity view widget (for live preview) */
+    readonly viewEntityData: _angular_core.Signal<Record<string, unknown>>;
+    onEdit(entity: Entity): void;
+    onDelete(_entity: Entity): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollectionViewPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollectionViewPage, "mcms-collection-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Entity Form Widget Types
+ *
+ * Types for the entity form widget that handles create/edit operations.
+ */
+
+/**
+ * Form mode - create, edit, or view.
+ */
+type EntityFormMode = 'create' | 'edit' | 'view';
+/**
+ * Minimal interface for accessing a FieldState from a signal forms FieldTree node.
+ * FieldTree nodes are callable — calling one returns its FieldState.
+ */
+interface FieldNodeState {
+    readonly value: WritableSignal<unknown>;
+    readonly errors: Signal<ReadonlyArray<{
+        kind: string;
+        message?: string;
+    }>>;
+    readonly touched: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    readonly invalid: Signal<boolean>;
+    markAsTouched(): void;
+    reset(value?: unknown): void;
+}
+/**
+ * Safely extract FieldState from an unknown FieldTree node.
+ * FieldTree nodes are callable functions — invoking returns the FieldState.
+ */
+declare function getFieldNodeState(formNode: unknown): FieldNodeState | null;
+/**
+ * Get a sub-node from a FieldTree node by key (field name or array index).
+ */
+declare function getSubNode(parentNode: unknown, key: string | number): unknown;
+/**
+ * Get the best title field name from a collection config.
+ * Checks admin.useAsTitle first, then falls back to 'title' or 'name' fields.
+ */
+declare function getTitleField(config: Record<string, unknown>): string;
+
+/**
+ * Collection Edit Page Component
+ *
+ * Form for creating or editing a document in a collection using EntityFormWidget.
+ * When preview is enabled on the collection, shows a live preview panel alongside the form.
+ */
+declare class CollectionEditPage implements HasUnsavedChanges {
+    private readonly route;
+    private readonly dialogService;
+    private readonly collectionAccess;
+    readonly basePath = "/admin/collections";
+    /** Whether the live preview panel is visible */
+    readonly showPreview: _angular_core.WritableSignal<boolean>;
+    /** Reference to the entity form widget to read its formData signal */
+    private readonly entityFormRef;
+    readonly entityId: _angular_core.Signal<string | undefined>;
+    readonly mode: _angular_core.Signal<EntityFormMode>;
+    readonly collection: _angular_core.Signal<CollectionConfig | undefined>;
+    /** Preview config from collection admin settings (false-y when not configured) */
+    readonly previewConfig: _angular_core.Signal<boolean | ((doc: Record<string, unknown>) => string) | undefined>;
+    /** Reactive form data from the entity form widget */
+    readonly formData: _angular_core.Signal<Record<string, unknown>>;
+    /** HasUnsavedChanges implementation for the route guard */
+    hasUnsavedChanges(): boolean;
+    /** Handle edit block request from preview iframe overlay */
+    onEditBlockRequest(blockIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollectionEditPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollectionEditPage, "mcms-collection-edit", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Login Page Component
+ *
+ * Allows users to sign in with email and password, or via OAuth providers.
+ */
+declare class LoginPage implements OnInit {
+    private readonly auth;
+    private readonly router;
+    /** Whether the component has been hydrated (SSR → client transition complete) */
+    readonly hydrated: _angular_core.WritableSignal<boolean>;
+    constructor();
+    readonly email: _angular_core.WritableSignal<string>;
+    readonly password: _angular_core.WritableSignal<string>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly isSubmitting: _angular_core.WritableSignal<boolean>;
+    readonly touched: _angular_core.WritableSignal<boolean>;
+    readonly oauthProviders: _angular_core.WritableSignal<string[]>;
+    readonly emailErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly passwordErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly isValid: _angular_core.Signal<boolean>;
+    ngOnInit(): Promise<void>;
+    signInWithOAuth(provider: string): void;
+    onSubmit(event: Event): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoginPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoginPage, "mcms-login-page", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Setup Page Component
+ *
+ * First-time setup page for creating the initial admin user.
+ * Only accessible when no users exist in the database.
+ */
+declare class SetupPage {
+    private readonly auth;
+    private readonly router;
+    /** Whether the component has been hydrated (SSR → client transition complete) */
+    readonly hydrated: _angular_core.WritableSignal<boolean>;
+    constructor();
+    readonly name: _angular_core.WritableSignal<string>;
+    readonly email: _angular_core.WritableSignal<string>;
+    readonly password: _angular_core.WritableSignal<string>;
+    readonly confirmPassword: _angular_core.WritableSignal<string>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly isSubmitting: _angular_core.WritableSignal<boolean>;
+    readonly touched: _angular_core.WritableSignal<boolean>;
+    readonly nameErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly emailErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly passwordErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly confirmPasswordErrors: _angular_core.Signal<{
+        kind: string;
+        message: string;
+    }[]>;
+    readonly isValid: _angular_core.Signal<boolean>;
+    onSubmit(event: Event): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SetupPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SetupPage, "mcms-setup-page", never, {}, {}, never, never, true, never>;
+}
+
+/** Helper type to represent media document from API */
+interface MediaItem$1 {
+    id: string;
+    filename: string;
+    mimeType: string;
+    path: string;
+    url?: string;
+    filesize?: number;
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Media Library Page
+ *
+ * Full-page view for managing media files: browse, upload, and delete.
+ */
+declare class MediaLibraryPage {
+    private readonly document;
+    private readonly api;
+    private readonly uploadService;
+    private readonly feedback;
+    private readonly toast;
+    private readonly dialog;
+    private readonly destroyRef;
+    private readonly uploadSubscriptions;
+    /** Internal state */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly mediaItems: _angular_core.WritableSignal<MediaItem$1[]>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    readonly totalPages: _angular_core.WritableSignal<number>;
+    readonly totalDocs: _angular_core.WritableSignal<number>;
+    readonly limit: _angular_core.WritableSignal<number>;
+    readonly selectedItems: _angular_core.WritableSignal<Set<string>>;
+    readonly activeUploads: _angular_core.WritableSignal<UploadProgress[]>;
+    constructor();
+    /**
+     * Load media from the API.
+     */
+    private loadMedia;
+    /**
+     * Handle search query change.
+     */
+    onSearchChange(query: string): void;
+    /**
+     * Handle page change.
+     */
+    onPageChange(page: number): void;
+    /**
+     * Handle file selection from input.
+     */
+    onFilesSelected(event: Event): void;
+    /**
+     * Update upload progress in the active uploads list.
+     */
+    private updateUploadProgress;
+    /**
+     * Remove upload from active uploads list.
+     */
+    private removeUpload;
+    /**
+     * Toggle selection of a media item.
+     */
+    toggleSelection(media: MediaItem$1): void;
+    /**
+     * View media file in a new tab.
+     */
+    viewMedia(media: MediaItem$1): void;
+    /**
+     * Open the edit dialog for a media item.
+     */
+    editMedia(media: MediaItem$1): void;
+    /**
+     * Delete a single media item.
+     */
+    deleteMedia(media: MediaItem$1): Promise<void>;
+    /**
+     * Delete all selected media items.
+     */
+    deleteSelected(): Promise<void>;
+    /**
+     * Get the URL for a media document.
+     */
+    getMediaUrl(media: MediaItem$1): string;
+    /**
+     * Format file size for display.
+     */
+    formatFileSize(bytes?: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MediaLibraryPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MediaLibraryPage, "mcms-media-library", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Forgot Password Page
+ *
+ * Full-page wrapper for the forgot password form.
+ * Uses a centered card layout matching the login page.
+ */
+declare class ForgotPasswordPage {
+    private readonly router;
+    navigateToLogin(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForgotPasswordPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ForgotPasswordPage, "mcms-forgot-password-page", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Reset Password Page
+ *
+ * Full-page wrapper for the reset password form.
+ * Reads the token from query parameters and passes it to the form.
+ */
+declare class ResetPasswordPage implements OnInit {
+    private readonly router;
+    private readonly route;
+    readonly token: _angular_core.WritableSignal<string>;
+    ngOnInit(): void;
+    navigateToLogin(): void;
+    navigateToForgotPassword(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResetPasswordPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResetPasswordPage, "mcms-reset-password-page", never, {}, {}, never, never, true, never>;
+}
+
+interface CollectionGroup {
+    name: string;
+    collections: CollectionConfig[];
+}
+interface GlobalGroup {
+    name: string;
+    globals: GlobalConfig[];
+}
+interface PluginRouteGroup {
+    name: string;
+    routes: AdminPluginRoute[];
+}
+/**
+ * Admin Sidebar Widget
+ *
+ * CMS-specific sidebar with collection navigation and user section.
+ * Composes UI library Sidebar components with Momentum CMS logic.
+ *
+ * Features:
+ * - Collection grouping via admin.group field
+ * - Plugin-registered route sections
+ *
+ * @example
+ * ```html
+ * <mcms-admin-sidebar
+ *   [branding]="{ title: 'My CMS', logo: '/logo.svg' }"
+ *   [collections]="collections"
+ *   [pluginRoutes]="pluginRoutes"
+ *   [user]="currentUser"
+ *   basePath="/admin"
+ *   (signOut)="onSignOut()"
+ * />
+ * ```
+ */
+declare class AdminSidebarWidget {
+    readonly theme: McmsThemeService;
+    /** Branding configuration (logo, title) */
+    readonly branding: _angular_core.InputSignal<AdminBranding | undefined>;
+    /** Collections to display in navigation */
+    readonly collections: _angular_core.InputSignal<CollectionConfig[]>;
+    /** Globals to display in navigation */
+    readonly globals: _angular_core.InputSignal<GlobalConfig[]>;
+    /** Plugin-registered admin routes */
+    readonly pluginRoutes: _angular_core.InputSignal<AdminPluginRoute[]>;
+    /** Current authenticated user */
+    readonly user: _angular_core.InputSignal<AdminUser | null>;
+    /** Base path for admin routes */
+    readonly basePath: _angular_core.InputSignal<string>;
+    /** Whether the sidebar is collapsed */
+    readonly collapsed: _angular_core.InputSignal<boolean>;
+    /** Sidebar width */
+    readonly width: _angular_core.InputSignal<string>;
+    /** Emitted when user clicks sign out */
+    readonly signOut: _angular_core.OutputEmitterRef<void>;
+    /** Computed collections base path */
+    readonly collectionsBasePath: _angular_core.Signal<string>;
+    /** Collections grouped by admin.group field */
+    readonly collectionGroups: _angular_core.Signal<CollectionGroup[]>;
+    /** Globals grouped by admin.group field */
+    readonly globalGroups: _angular_core.Signal<GlobalGroup[]>;
+    /** Plugin routes grouped by group field */
+    readonly pluginRouteGroups: _angular_core.Signal<PluginRouteGroup[]>;
+    /** Collection icon names by slug */
+    private readonly collectionIcons;
+    /**
+     * Get display label for a collection.
+     */
+    getCollectionLabel(collection: CollectionConfig): string;
+    /**
+     * Get router path for a collection.
+     */
+    getCollectionPath(collection: CollectionConfig): string;
+    /**
+     * Get icon name for a collection based on its slug.
+     */
+    getCollectionIcon(collection: CollectionConfig): string;
+    /**
+     * Get display label for a global.
+     */
+    getGlobalLabel(global: GlobalConfig): string;
+    /**
+     * Get initials from user name.
+     */
+    getUserInitials(name: string): string;
+    /**
+     * Toggle theme between light and dark.
+     */
+    toggleTheme(): void;
+    /**
+     * Handle sign out click.
+     */
+    onSignOutClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdminSidebarWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AdminSidebarWidget, "mcms-admin-sidebar", never, { "branding": { "alias": "branding"; "required": false; "isSignal": true; }; "collections": { "alias": "collections"; "required": false; "isSignal": true; }; "globals": { "alias": "globals"; "required": false; "isSignal": true; }; "pluginRoutes": { "alias": "pluginRoutes"; "required": false; "isSignal": true; }; "user": { "alias": "user"; "required": false; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "signOut": "signOut"; }, never, never, true, never>;
+}
+
+/**
+ * Collection Card Widget
+ *
+ * Displays a collection card with document count fetched from API.
+ * Useful for dashboard overviews and collection navigation.
+ *
+ * @example
+ * ```html
+ * <mcms-collection-card
+ *   [collection]="postsCollection"
+ *   basePath="/admin/collections"
+ *   (viewAll)="navigateToCollection($event)"
+ * />
+ * ```
+ */
+declare class CollectionCardWidget {
+    private readonly api;
+    private readonly collectionAccess;
+    /** The collection to display */
+    readonly collection: _angular_core.InputSignal<CollectionConfig>;
+    /** Base path for collection routes */
+    readonly basePath: _angular_core.InputSignal<string>;
+    /** Whether to show document count */
+    readonly showDocumentCount: _angular_core.InputSignal<boolean>;
+    /** Emitted when view all is clicked */
+    readonly viewAll: _angular_core.OutputEmitterRef<CollectionConfig>;
+    /** Document count from API */
+    readonly count: _angular_core.WritableSignal<number>;
+    /** Whether count is loading */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Error message if count fetch failed */
+    readonly error: _angular_core.WritableSignal<string | null>;
+    /** Display label for the collection */
+    readonly collectionLabel: _angular_core.Signal<string>;
+    /** Lowercase label for descriptions */
+    readonly collectionLabelLower: _angular_core.Signal<string>;
+    /** Path to view all documents */
+    readonly viewPath: _angular_core.Signal<string>;
+    /** Path to create new document */
+    readonly createPath: _angular_core.Signal<string>;
+    /** Whether user can create documents */
+    readonly canCreate: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Fetch document count for the collection.
+     */
+    private fetchCount;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollectionCardWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollectionCardWidget, "mcms-collection-card", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "showDocumentCount": { "alias": "showDocumentCount"; "required": false; "isSignal": true; }; }, { "viewAll": "viewAll"; }, never, never, true, never>;
+}
+
+/**
+ * Entity Form Widget
+ *
+ * Dynamic form for create/edit operations using Angular Signal Forms.
+ *
+ * @example
+ * ```html
+ * <mcms-entity-form
+ *   [collection]="postsCollection"
+ *   entityId="123"
+ *   mode="edit"
+ *   (saved)="onSaved($event)"
+ *   (cancelled)="onCancel()"
+ * />
+ * ```
+ */
+declare class EntityFormWidget<T extends Entity = Entity> {
+    private readonly api;
+    private readonly injector;
+    private readonly versionService;
+    private readonly collectionAccess;
+    private readonly feedback;
+    private readonly router;
+    private readonly liveAnnouncer;
+    /** The collection configuration */
+    readonly collection: _angular_core.InputSignal<CollectionConfig>;
+    /** Entity ID for edit mode (undefined for create) */
+    readonly entityId: _angular_core.InputSignal<string | undefined>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Base path for navigation */
+    readonly basePath: _angular_core.InputSignal<string>;
+    /** Whether to show breadcrumbs */
+    readonly showBreadcrumbs: _angular_core.InputSignal<boolean>;
+    /** When true, prevents router navigation after save/cancel (used in entity sheet) */
+    readonly suppressNavigation: _angular_core.InputSignal<boolean>;
+    /** When true, uses the global API instead of collection API (singleton mode) */
+    readonly isGlobal: _angular_core.InputSignal<boolean>;
+    /** The global slug (used when isGlobal is true) */
+    readonly globalSlug: _angular_core.InputSignal<string | undefined>;
+    /** Outputs */
+    readonly saved: _angular_core.OutputEmitterRef<T>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly saveError: _angular_core.OutputEmitterRef<Error>;
+    readonly modeChange: _angular_core.OutputEmitterRef<EntityFormMode>;
+    readonly draftSaved: _angular_core.OutputEmitterRef<void>;
+    /** Model signal — the single source of truth for form data */
+    readonly formModel: _angular_core.WritableSignal<Record<string, unknown>>;
+    /** Alias for backward compatibility (CollectionEditPage reads formData) */
+    readonly formData: _angular_core.WritableSignal<Record<string, unknown>>;
+    /** Signal forms tree — created once when collection is available */
+    readonly entityForm: _angular_core.WritableSignal<_angular_forms_signals.FieldTree<Record<string, unknown>, string | number> | null>;
+    /** Original data for edit mode */
+    readonly originalData: _angular_core.WritableSignal<T | null>;
+    /** UI state */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly isSubmitting: _angular_core.WritableSignal<boolean>;
+    readonly isSavingDraft: _angular_core.WritableSignal<boolean>;
+    readonly formError: _angular_core.WritableSignal<string | null>;
+    /** Whether the form has been set up */
+    private formCreated;
+    /** Whether the form has unsaved changes (from signal forms dirty tracking) */
+    readonly isDirty: _angular_core.Signal<boolean>;
+    /** Computed collection label */
+    readonly collectionLabel: _angular_core.Signal<string>;
+    /** Computed collection label singular */
+    readonly collectionLabelSingular: _angular_core.Signal<string>;
+    /** Dashboard path (remove /collections from base path) */
+    readonly dashboardPath: _angular_core.Signal<string>;
+    /** Collection list path */
+    readonly collectionListPath: _angular_core.Signal<string>;
+    /** Page title for breadcrumb */
+    readonly pageTitle: _angular_core.Signal<string>;
+    /** Visible fields (excluding hidden ones and those failing admin.condition) */
+    readonly visibleFields: _angular_core.Signal<Field[]>;
+    /** Whether user can edit */
+    readonly canEdit: _angular_core.Signal<boolean>;
+    /** Whether collection has versioning with drafts enabled */
+    readonly hasVersioning: _angular_core.Signal<boolean>;
+    /** Whether draft save is available (edit mode with existing entity) */
+    readonly canSaveDraft: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Get a FieldTree node for a top-level field by name.
+     */
+    getFormNode(fieldName: string): unknown;
+    /**
+     * Load entity for edit mode.
+     */
+    private loadEntity;
+    /**
+     * Load global singleton document.
+     */
+    private loadGlobal;
+    /**
+     * Handle form submission using Angular Signal Forms submit().
+     * submit() marks all fields as touched, then only calls the callback if valid.
+     */
+    onSubmit(): Promise<void>;
+    /**
+     * Handle cancel.
+     */
+    onCancel(): void;
+    /**
+     * Switch from view to edit mode.
+     */
+    switchToEdit(): void;
+    /**
+     * Handle version restore — reload the entity data.
+     */
+    onVersionRestored(): void;
+    /**
+     * Save form data as a draft.
+     */
+    onSaveDraft(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityFormWidget<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityFormWidget<any>, "mcms-entity-form", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; "isSignal": true; }; "suppressNavigation": { "alias": "suppressNavigation"; "required": false; "isSignal": true; }; "isGlobal": { "alias": "isGlobal"; "required": false; "isSignal": true; }; "globalSlug": { "alias": "globalSlug"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "cancelled": "cancelled"; "saveError": "saveError"; "modeChange": "modeChange"; "draftSaved": "draftSaved"; }, never, ["[entityFormHeaderExtra]"], true, never>;
+}
+
+/**
+ * Field display configuration for the entity view.
+ */
+interface EntityViewFieldConfig {
+    /** Field name */
+    field: string;
+    /** Display label (defaults to field name) */
+    label?: string;
+    /** Display type override */
+    type?: 'text' | 'number' | 'date' | 'datetime' | 'boolean' | 'badge' | 'link' | 'email' | 'list' | 'json' | 'html' | 'group' | 'array-table';
+    /** Custom formatter function */
+    formatter?: (value: unknown, entity: Entity) => string;
+    /** Whether to hide this field */
+    hidden?: boolean;
+}
+/**
+ * Breadcrumb item for navigation.
+ */
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+/**
+ * Entity view action event.
+ */
+interface EntityViewActionEvent {
+    action: EntityAction;
+    entity: Entity;
+}
+
+/**
+ * Entity View Widget
+ *
+ * Read-only entity display connected to Momentum API.
+ *
+ * @example
+ * ```html
+ * <mcms-entity-view
+ *   [collection]="postsCollection"
+ *   entityId="123"
+ *   (edit)="onEdit($event)"
+ *   (delete)="onDelete($event)"
+ * />
+ * ```
+ */
+declare class EntityViewWidget<T extends Entity = Entity> {
+    private readonly api;
+    private readonly collectionAccess;
+    private readonly feedback;
+    private readonly router;
+    /** The collection configuration */
+    readonly collection: _angular_core.InputSignal<CollectionConfig>;
+    /** Entity ID to view */
+    readonly entityId: _angular_core.InputSignal<string>;
+    /** Base path for navigation */
+    readonly basePath: _angular_core.InputSignal<string>;
+    /** Whether to show breadcrumbs */
+    readonly showBreadcrumbs: _angular_core.InputSignal<boolean>;
+    /** Custom field configurations */
+    readonly fieldConfigs: _angular_core.InputSignal<EntityViewFieldConfig[]>;
+    /** Additional actions to show */
+    readonly actions: _angular_core.InputSignal<EntityAction[]>;
+    /** Whether to show version history (only shown if versioning is enabled) */
+    readonly showVersionHistory: _angular_core.InputSignal<boolean>;
+    /** When true, prevents router navigation (used in entity sheet) */
+    readonly suppressNavigation: _angular_core.InputSignal<boolean>;
+    /** Outputs */
+    readonly edit: _angular_core.OutputEmitterRef<T>;
+    readonly statusChanged: _angular_core.OutputEmitterRef<DocumentStatus$1>;
+    readonly delete_: _angular_core.OutputEmitterRef<T>;
+    readonly actionClick: _angular_core.OutputEmitterRef<{
+        action: EntityAction;
+        entity: T;
+    }>;
+    /** Internal state */
+    readonly entity: _angular_core.WritableSignal<T | null>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly loadError: _angular_core.WritableSignal<string | null>;
+    readonly resolvedRelationships: _angular_core.WritableSignal<Map<string, string>>;
+    /** Computed collection label */
+    readonly collectionLabel: _angular_core.Signal<string>;
+    /** Computed collection label singular */
+    readonly collectionLabelSingular: _angular_core.Signal<string>;
+    /** Entity title (uses title field or ID) */
+    readonly entityTitle: _angular_core.Signal<string>;
+    /** Visible fields (excluding hidden ones) */
+    readonly visibleFields: _angular_core.Signal<Field[]>;
+    /** Whether collection has timestamps */
+    readonly hasTimestamps: _angular_core.Signal<boolean>;
+    /** Dashboard path */
+    readonly dashboardPath: _angular_core.Signal<string>;
+    /** Collection list path */
+    readonly collectionListPath: _angular_core.Signal<string>;
+    /** Whether user can edit */
+    readonly canEdit: _angular_core.Signal<boolean>;
+    /** Whether user can delete */
+    readonly canDelete: _angular_core.Signal<boolean>;
+    /** Whether collection has soft delete enabled */
+    readonly hasSoftDelete: _angular_core.Signal<boolean>;
+    /** Whether the current entity is soft-deleted */
+    readonly isDeleted: _angular_core.Signal<boolean>;
+    /** Whether collection has versioning enabled */
+    readonly hasVersioning: _angular_core.Signal<boolean>;
+    /** Current document status (from entity or default to 'draft') */
+    readonly documentStatus: _angular_core.Signal<DocumentStatus$1>;
+    /** Preview URL derived from collection's admin.preview config */
+    readonly previewUrl: _angular_core.Signal<string | null>;
+    constructor();
+    /**
+     * Load entity from API.
+     */
+    private loadEntity;
+    /**
+     * Get field value from entity, resolving relationship labels.
+     */
+    getFieldValue(fieldName: string): unknown;
+    /**
+     * Get field display type from field definition.
+     */
+    getFieldDisplayType(field: Field): FieldDisplayType;
+    /**
+     * Get sub-field metadata for group and array field types.
+     */
+    getFieldMeta(field: Field): FieldDisplayFieldMeta[];
+    /**
+     * Get number format config from field definition.
+     */
+    getNumberFormat(field: Field): FieldDisplayNumberFormat | undefined;
+    /**
+     * Get date format config from field definition.
+     */
+    getDateFormat(field: Field): FieldDisplayDateFormat | undefined;
+    /**
+     * Handle edit button click.
+     */
+    onEditClick(): void;
+    /**
+     * Handle delete button click.
+     */
+    onDeleteClick(): Promise<void>;
+    onRestoreClick(): Promise<void>;
+    onForceDeleteClick(): Promise<void>;
+    /**
+     * Handle custom action click.
+     */
+    onActionClick(action: EntityAction): void;
+    /**
+     * Navigate back to collection list.
+     */
+    navigateBack(): void;
+    /**
+     * Handle status change from publish controls.
+     */
+    onStatusChanged(status: DocumentStatus$1): void;
+    /**
+     * Handle version restoration.
+     */
+    onVersionRestored(): void;
+    /**
+     * Resolve relationship field values from IDs to display labels.
+     */
+    private resolveRelationships;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityViewWidget<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityViewWidget<any>, "mcms-entity-view", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": true; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; "isSignal": true; }; "fieldConfigs": { "alias": "fieldConfigs"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "showVersionHistory": { "alias": "showVersionHistory"; "required": false; "isSignal": true; }; "suppressNavigation": { "alias": "suppressNavigation"; "required": false; "isSignal": true; }; }, { "edit": "edit"; "statusChanged": "statusChanged"; "delete_": "delete_"; "actionClick": "actionClick"; }, never, ["[entityViewHeaderExtra]"], true, never>;
+}
+
+/**
+ * Feedback Service
+ *
+ * CMS-specific toast messages and confirmations for entity operations.
+ * Wraps the UI library's ToastService and ConfirmationService with
+ * convenience methods for common CMS operations.
+ *
+ * @example
+ * ```typescript
+ * const feedback = inject(FeedbackService);
+ *
+ * // Success messages
+ * feedback.entityCreated('Post');
+ * feedback.entityUpdated('Post');
+ * feedback.entityDeleted('Post');
+ *
+ * // Error messages
+ * feedback.operationFailed('Failed to save', error);
+ *
+ * // Confirmations
+ * const confirmed = await feedback.confirmDelete('Post', 'My Blog Post');
+ * if (confirmed) {
+ *   // Proceed with deletion
+ * }
+ * ```
+ */
+declare class FeedbackService {
+    private readonly toast;
+    private readonly confirmation;
+    /**
+     * Show success message when an entity is created.
+     */
+    entityCreated(collectionLabel: string): void;
+    /**
+     * Show success message when an entity is updated.
+     */
+    entityUpdated(collectionLabel: string): void;
+    /**
+     * Show success message when an entity is deleted.
+     */
+    entityDeleted(collectionLabel: string): void;
+    /**
+     * Show success message when multiple entities are deleted.
+     */
+    entitiesDeleted(collectionLabel: string, count: number): void;
+    /**
+     * Show success message when an entity is published.
+     */
+    entityPublished(collectionLabel: string): void;
+    /**
+     * Show success message when an entity is unpublished.
+     */
+    entityUnpublished(collectionLabel: string): void;
+    /**
+     * Show error message when an operation fails.
+     */
+    operationFailed(message: string, error?: Error): void;
+    /**
+     * Show error message when validation fails.
+     */
+    validationFailed(fieldCount: number): void;
+    /**
+     * Show error message when not authorized.
+     */
+    notAuthorized(action: string): void;
+    /**
+     * Show error message when entity not found.
+     */
+    entityNotFound(collectionLabel: string): void;
+    /**
+     * Show warning about unsaved changes.
+     */
+    unsavedChanges(): void;
+    /**
+     * Confirm delete operation for a single entity.
+     * @param collectionLabel The collection label (e.g., "Post")
+     * @param entityTitle The entity title to display (optional)
+     * @returns Promise resolving to true if confirmed
+     */
+    confirmDelete(collectionLabel: string, entityTitle?: string): Promise<boolean>;
+    /**
+     * Confirm bulk delete operation.
+     * @param collectionLabel The collection label (e.g., "Posts")
+     * @param count Number of items to delete
+     * @returns Promise resolving to true if confirmed
+     */
+    confirmBulkDelete(collectionLabel: string, count: number): Promise<boolean>;
+    /**
+     * Confirm discard changes.
+     * @returns Promise resolving to true if confirmed
+     */
+    confirmDiscard(): Promise<boolean>;
+    /**
+     * Confirm unpublish operation.
+     * @param collectionLabel The collection label
+     * @returns Promise resolving to true if confirmed
+     */
+    confirmUnpublish(collectionLabel: string): Promise<boolean>;
+    /**
+     * Confirm restore version operation.
+     * @param collectionLabel The collection label
+     * @returns Promise resolving to true if confirmed
+     */
+    confirmRestore(collectionLabel: string): Promise<boolean>;
+    /**
+     * Show success message when a version is restored.
+     */
+    versionRestored(collectionLabel: string): void;
+    /**
+     * Show success message when a draft is saved.
+     */
+    draftSaved(): void;
+    /**
+     * Show confirmation with custom config.
+     */
+    confirm(config: {
+        title: string;
+        description: string;
+        confirmText?: string;
+        cancelText?: string;
+        variant?: 'default' | 'destructive';
+    }): Promise<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeedbackService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FeedbackService>;
+}
+
+/**
+ * Version History Widget
+ *
+ * Displays a list of document versions with the ability to restore previous versions.
+ *
+ * @example
+ * ```html
+ * <mcms-version-history
+ *   [collection]="'posts'"
+ *   [documentId]="'abc123'"
+ *   [documentLabel]="'Post'"
+ *   (restored)="onVersionRestored($event)"
+ * />
+ * ```
+ */
+declare class VersionHistoryWidget {
+    private readonly versionService;
+    private readonly feedback;
+    private readonly dialogService;
+    /** Collection slug */
+    readonly collection: _angular_core.InputSignal<string>;
+    /** Document ID */
+    readonly documentId: _angular_core.InputSignal<string>;
+    /** Document label for feedback messages */
+    readonly documentLabel: _angular_core.InputSignal<string>;
+    /** Emitted when a version is restored */
+    readonly restored: _angular_core.OutputEmitterRef<DocumentVersionParsed<Record<string, unknown>>>;
+    /** Versions list */
+    readonly versions: _angular_core.WritableSignal<DocumentVersionParsed<Record<string, unknown>>[]>;
+    /** Whether versions are loading */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Whether more versions are loading */
+    readonly isLoadingMore: _angular_core.WritableSignal<boolean>;
+    /** Whether a restore is in progress */
+    readonly isRestoring: _angular_core.WritableSignal<boolean>;
+    /** ID of the version being restored */
+    readonly restoringVersionId: _angular_core.WritableSignal<string | null>;
+    /** Error message */
+    readonly error: _angular_core.WritableSignal<string | null>;
+    /** Current page */
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    /** Whether there are more versions */
+    readonly hasNextPage: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Load versions from the API.
+     */
+    private loadVersions;
+    /**
+     * Load more versions.
+     */
+    loadMore(): void;
+    /**
+     * Restore a version.
+     */
+    onRestore(version: DocumentVersionParsed): Promise<void>;
+    /**
+     * Compare a version with the current (most recent) version.
+     */
+    onCompare(version: DocumentVersionParsed): void;
+    /**
+     * Get badge variant for status.
+     */
+    getStatusVariant(status: DocumentStatus): 'default' | 'secondary' | 'destructive' | 'outline';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionHistoryWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VersionHistoryWidget, "mcms-version-history", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "documentId": { "alias": "documentId"; "required": true; "isSignal": true; }; "documentLabel": { "alias": "documentLabel"; "required": false; "isSignal": true; }; }, { "restored": "restored"; }, never, never, true, never>;
+}
+
+/**
+ * Publish Controls Widget
+ *
+ * Displays the current document status and provides publish/unpublish actions.
+ *
+ * @example
+ * ```html
+ * <mcms-publish-controls
+ *   [collection]="'posts'"
+ *   [documentId]="'abc123'"
+ *   [documentLabel]="'Post'"
+ *   (statusChanged)="onStatusChanged($event)"
+ * />
+ * ```
+ */
+declare class PublishControlsWidget {
+    private readonly versionService;
+    private readonly feedback;
+    /** Collection slug */
+    readonly collection: _angular_core.InputSignal<string>;
+    /** Document ID */
+    readonly documentId: _angular_core.InputSignal<string>;
+    /** Document label for feedback messages */
+    readonly documentLabel: _angular_core.InputSignal<string>;
+    /** Initial status (optional, will be fetched if not provided) */
+    readonly initialStatus: _angular_core.InputSignal<DocumentStatus | undefined>;
+    /** Emitted when the status changes */
+    readonly statusChanged: _angular_core.OutputEmitterRef<DocumentStatus>;
+    /** Current status */
+    readonly status: _angular_core.WritableSignal<DocumentStatus>;
+    /** Whether a status update is in progress */
+    readonly isUpdating: _angular_core.WritableSignal<boolean>;
+    /** Whether status is loading */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Badge variant based on status (derived from status signal) */
+    readonly statusVariant: _angular_core.Signal<"default" | "secondary" | "outline">;
+    /** Status label (derived from status signal) */
+    readonly statusLabel: _angular_core.Signal<"Published" | "Draft">;
+    constructor();
+    /**
+     * Load the current status from the API.
+     */
+    private loadStatus;
+    /**
+     * Update the status display.
+     * statusVariant and statusLabel are computed signals that automatically update.
+     */
+    private updateStatusDisplay;
+    /**
+     * Publish the document.
+     */
+    onPublish(): Promise<void>;
+    /**
+     * Unpublish the document.
+     */
+    onUnpublish(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PublishControlsWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PublishControlsWidget, "mcms-publish-controls", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "documentId": { "alias": "documentId"; "required": true; "isSignal": true; }; "documentLabel": { "alias": "documentLabel"; "required": false; "isSignal": true; }; "initialStatus": { "alias": "initialStatus"; "required": false; "isSignal": true; }; }, { "statusChanged": "statusChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Media document data for preview.
+ */
+interface MediaPreviewData {
+    url?: string;
+    path?: string;
+    mimeType?: string;
+    filename?: string;
+    alt?: string;
+}
+/**
+ * Media Preview Component
+ *
+ * Displays a preview of media based on its type:
+ * - Images: Thumbnail preview
+ * - Videos: Video icon with optional poster
+ * - Audio: Audio icon
+ * - Documents: Document icon
+ * - Other: Generic file icon
+ *
+ * @example
+ * ```html
+ * <mcms-media-preview
+ *   [media]="mediaDocument"
+ *   [size]="'md'"
+ * />
+ * ```
+ */
+declare class MediaPreviewComponent {
+    /** Media data to preview */
+    readonly media: _angular_core.InputSignal<MediaPreviewData | null>;
+    /** Size of the preview */
+    readonly size: _angular_core.InputSignal<"xs" | "sm" | "md" | "lg" | "xl">;
+    /** Custom class override */
+    readonly class: _angular_core.InputSignal<string>;
+    /** Whether to show rounded corners */
+    readonly rounded: _angular_core.InputSignal<boolean>;
+    /** Host classes */
+    readonly hostClasses: _angular_core.Signal<string>;
+    /** Size classes map */
+    private readonly sizeClasses;
+    /** Icon size classes */
+    readonly iconClasses: _angular_core.Signal<string>;
+    /** Whether the media is an image */
+    readonly isImage: _angular_core.Signal<boolean>;
+    /** Whether the media is a video */
+    readonly isVideo: _angular_core.Signal<boolean>;
+    /** Whether the media is audio */
+    readonly isAudio: _angular_core.Signal<boolean>;
+    /** Image URL for preview */
+    readonly imageUrl: _angular_core.Signal<string>;
+    /** Icon name based on media type */
+    readonly iconName: _angular_core.Signal<"<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M3.375 19.5h17.25m-17.25 0a1.125 1.125 0 0 1-1.125-1.125M3.375 19.5h1.5C5.496 19.5 6 18.996 6 18.375m-3.75 0V5.625m0 12.75v-1.5c0-.621.504-1.125 1.125-1.125m18.375 2.625V5.625m0 12.75c0 .621-.504 1.125-1.125 1.125m1.125-1.125v-1.5c0-.621-.504-1.125-1.125-1.125m0 3.75h-1.5A1.125 1.125 0 0 1 18 18.375M20.625 4.5H3.375m17.25 0c.621 0 1.125.504 1.125 1.125M20.625 4.5h-1.5C18.504 4.5 18 5.004 18 5.625m3.75 0v1.5c0 .621-.504 1.125-1.125 1.125M3.375 4.5c-.621 0-1.125.504-1.125 1.125M3.375 4.5h1.5C5.496 4.5 6 5.004 6 5.625m-3.75 0v1.5c0 .621.504 1.125 1.125 1.125m0 0h1.5m-1.5 0c-.621 0-1.125.504-1.125 1.125v1.5c0 .621.504 1.125 1.125 1.125m1.5-3.75C5.496 8.25 6 7.746 6 7.125v-1.5M4.875 8.25C5.496 8.25 6 8.754 6 9.375v1.5m0-5.25v5.25m0-5.25C6 5.004 6.504 4.5 7.125 4.5h9.75c.621 0 1.125.504 1.125 1.125m1.125 2.625h1.5m-1.5 0A1.125 1.125 0 0 1 18 7.125v-1.5m1.125 2.625c-.621 0-1.125.504-1.125 1.125v1.5m2.625-2.625c.621 0 1.125.504 1.125 1.125v1.5c0 .621-.504 1.125-1.125 1.125M18 5.625v5.25M7.125 12h9.75m-9.75 0A1.125 1.125 0 0 1 6 10.875M7.125 12C6.504 12 6 12.504 6 13.125m0-2.25C6 11.496 5.496 12 4.875 12M18 10.875c0 .621-.504 1.125-1.125 1.125M18 10.875c0 .621.504 1.125 1.125 1.125m-2.25 0c.621 0 1.125.504 1.125 1.125m-12 5.25v-5.25m0 5.25c0 .621.504 1.125 1.125 1.125h9.75c.621 0 1.125-.504 1.125-1.125m-12 0v-1.5c0-.621-.504-1.125-1.125-1.125M18 18.375v-5.25m0 5.25v-1.5c0-.621.504-1.125 1.125-1.125M18 13.125v1.5c0 .621.504 1.125 1.125 1.125M18 13.125c0-.621.504-1.125 1.125-1.125M6 13.125v1.5c0 .621-.504 1.125-1.125 1.125M6 13.125C6 12.504 5.496 12 4.875 12m-1.5 0h1.5m-1.5 0c-.621 0-1.125.504-1.125 1.125v1.5c0 .621.504 1.125 1.125 1.125M19.125 12h1.5m0 0c.621 0 1.125.504 1.125 1.125v1.5c0 .621-.504 1.125-1.125 1.125m-17.25 0h1.5m14.25 0h1.5\"></path></svg>" | "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"m9 9 10.5-3m0 6.553v3.75a2.25 2.25 0 0 1-1.632 2.163l-1.32.377a1.803 1.803 0 1 1-.99-3.467l2.31-.66a2.25 2.25 0 0 0 1.632-2.163Zm0 0V2.25L9 5.25v10.303m0 0v3.75a2.25 2.25 0 0 1-1.632 2.163l-1.32.377a1.803 1.803 0 0 1-.99-3.467l2.31-.66A2.25 2.25 0 0 0 9 15.553Z\"></path></svg>" | "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M19.5 14.25v-2.625a3.375 3.375 0 0 0-3.375-3.375h-1.5A1.125 1.125 0 0 1 13.5 7.125v-1.5a3.375 3.375 0 0 0-3.375-3.375H8.25m0 12.75h7.5m-7.5 3H12M10.5 2.25H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 0 0-9-9Z\"></path></svg>" | "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"m20.25 7.5-.625 10.632a2.25 2.25 0 0 1-2.247 2.118H6.622a2.25 2.25 0 0 1-2.247-2.118L3.75 7.5M10 11.25h4M3.375 7.5h17.25c.621 0 1.125-.504 1.125-1.125v-1.5c0-.621-.504-1.125-1.125-1.125H3.375c-.621 0-1.125.504-1.125 1.125v1.5c0 .621.504 1.125 1.125 1.125Z\"></path></svg>" | "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"m2.25 15.75 5.159-5.159a2.25 2.25 0 0 1 3.182 0l5.159 5.159m-1.5-1.5 1.409-1.409a2.25 2.25 0 0 1 3.182 0l2.909 2.909m-18 3.75h16.5a1.5 1.5 0 0 0 1.5-1.5V6a1.5 1.5 0 0 0-1.5-1.5H3.75A1.5 1.5 0 0 0 2.25 6v12a1.5 1.5 0 0 0 1.5 1.5Zm10.5-11.25h.008v.008h-.008V8.25Zm.375 0a.375.375 0 1 1-.75 0 .375.375 0 0 1 .75 0Z\"></path></svg>" | "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M19.5 14.25v-2.625a3.375 3.375 0 0 0-3.375-3.375h-1.5A1.125 1.125 0 0 1 13.5 7.125v-1.5a3.375 3.375 0 0 0-3.375-3.375H8.25m2.25 0H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 0 0-9-9Z\"></path></svg>">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MediaPreviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MediaPreviewComponent, "mcms-media-preview", never, { "media": { "alias": "media"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Device size preset for the preview iframe. */
+type DeviceSize = 'desktop' | 'tablet' | 'mobile';
+/**
+ * Live Preview Widget
+ *
+ * Displays an iframe that shows a live preview of the document being edited.
+ * Sends form data to the iframe via postMessage on each change.
+ */
+declare class LivePreviewComponent {
+    private readonly document;
+    private readonly sanitizer;
+    private readonly destroyRef;
+    /** Preview configuration from collection admin config */
+    readonly preview: _angular_core.InputSignal<boolean | ((doc: Record<string, unknown>) => string)>;
+    /** Current document data from the form */
+    readonly documentData: _angular_core.InputSignal<Record<string, unknown>>;
+    /** Collection slug */
+    readonly collectionSlug: _angular_core.InputSignal<string>;
+    /** Document ID (undefined for create mode) */
+    readonly entityId: _angular_core.InputSignal<string | undefined>;
+    /** Emitted when the preview iframe requests editing a block */
+    readonly editBlockRequest: _angular_core.OutputEmitterRef<number>;
+    /** Current device size */
+    readonly deviceSize: _angular_core.WritableSignal<DeviceSize>;
+    /** Refresh counter to force iframe reload */
+    private readonly refreshCounter;
+    /** Reference to the iframe element */
+    readonly previewFrame: _angular_core.Signal<ElementRef<HTMLIFrameElement> | undefined>;
+    /** Compute the raw preview URL */
+    readonly previewUrl: _angular_core.Signal<string | null>;
+    /** Sanitized preview URL for iframe binding */
+    readonly safePreviewUrl: _angular_core.Signal<SafeResourceUrl | null>;
+    /** Computed iframe width based on device size */
+    readonly iframeWidth: _angular_core.Signal<string>;
+    /** Debounce timer for postMessage updates */
+    private debounceTimer;
+    constructor();
+    /** Force iframe to reload */
+    refreshPreview(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LivePreviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LivePreviewComponent, "mcms-live-preview", never, { "preview": { "alias": "preview"; "required": true; "isSignal": true; }; "documentData": { "alias": "documentData"; "required": true; "isSignal": true; }; "collectionSlug": { "alias": "collectionSlug"; "required": true; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": false; "isSignal": true; }; }, { "editBlockRequest": "editBlockRequest"; }, never, never, true, never>;
+}
+
+/**
+ * Visual Block Editor - Shared Types
+ *
+ * Types, interfaces, and utilities for the WYSIWYG visual block editor.
+ */
+
+/** Shape of a block item in the stored data */
+interface BlockItem {
+    blockType: string;
+    [key: string]: unknown;
+}
+/** State for the visual block editor */
+interface VisualEditorState {
+    readonly selectedBlockIndex: WritableSignal<number | null>;
+    readonly hoveredBlockIndex: WritableSignal<number | null>;
+    readonly inserterOpen: WritableSignal<{
+        index: number;
+    } | null>;
+    readonly collapsedBlocks: WritableSignal<Set<number>>;
+}
+
+declare class VisualBlockEditorComponent {
+    /** Field definition (must be a BlocksField) */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this blocks array */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Root signal forms FieldTree */
+    readonly formTree: _angular_core.InputSignal<unknown>;
+    /** Form model data */
+    readonly formModel: _angular_core.InputSignal<Record<string, unknown>>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Editor state */
+    readonly editorState: VisualEditorState;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Computed description */
+    readonly description: _angular_core.Signal<string>;
+    /** Block type definitions from the field */
+    readonly blockDefinitions: _angular_core.Signal<BlockConfig[]>;
+    readonly minRows: _angular_core.Signal<number>;
+    readonly maxRows: _angular_core.Signal<number | undefined>;
+    /** Current blocks as typed items */
+    readonly blocks: _angular_core.Signal<BlockItem[]>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Normalize loaded blocks: ensure every block has defaults for all fields
+     * defined in its block definition. This is needed because blocks saved before
+     * a new field was added (e.g. _analytics) won't have those keys, and the
+     * signal-forms tree only creates controls for keys present in the model.
+     */
+    private readonly _normalizeBlocks;
+    readonly canRemoveBlock: _angular_core.Signal<boolean>;
+    /** Block definition lookup cache */
+    private readonly blockDefMap;
+    /** Fallback empty block config for unknown types */
+    private readonly emptyBlockConfig;
+    getBlockLabel(blockType: string): string;
+    getBlockConfig(blockType: string): BlockConfig;
+    isBlockCollapsed(index: number): boolean;
+    toggleBlockCollapse(index: number): void;
+    /** Shift collapsed indices after a block is added at atIndex */
+    private shiftCollapsedUp;
+    /** Shift collapsed indices after a block is removed at removedIndex */
+    private shiftCollapsedDown;
+    /** Swap collapsed state between two indices */
+    private swapCollapsed;
+    addBlock(blockType: string, atIndex: number): void;
+    removeBlock(index: number): void;
+    moveBlock(from: number, to: number): void;
+    selectBlock(index: number): void;
+    onDrop(event: CdkDragDrop<unknown>): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VisualBlockEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VisualBlockEditorComponent, "mcms-visual-block-editor", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "formTree": { "alias": "formTree"; "required": false; "isSignal": true; }; "formModel": { "alias": "formModel"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BlockWrapperComponent {
+    /** The block data */
+    readonly block: _angular_core.InputSignal<BlockItem>;
+    /** Block index in the blocks array */
+    readonly blockIndex: _angular_core.InputSignal<number>;
+    /** Block type configuration */
+    readonly blockConfig: _angular_core.InputSignal<BlockConfig>;
+    /** Human-readable block type label */
+    readonly blockLabel: _angular_core.InputSignal<string>;
+    /** Whether this block is currently selected */
+    readonly isSelected: _angular_core.InputSignal<boolean>;
+    /** Whether this block is currently hovered */
+    readonly isHovered: _angular_core.InputSignal<boolean>;
+    /** Whether the editor is in view/disabled mode */
+    readonly isDisabled: _angular_core.InputSignal<boolean>;
+    /** Whether this block is collapsed (fields hidden) */
+    readonly isCollapsed: _angular_core.InputSignal<boolean>;
+    /** Whether the block can be moved up */
+    readonly canMoveUp: _angular_core.InputSignal<boolean>;
+    /** Whether the block can be moved down */
+    readonly canMoveDown: _angular_core.InputSignal<boolean>;
+    /** Whether the block can be deleted */
+    readonly canDelete: _angular_core.InputSignal<boolean>;
+    /** Signal forms node for the blocks array */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Root signal forms FieldTree */
+    readonly formTree: _angular_core.InputSignal<unknown>;
+    /** Form model data */
+    readonly formModel: _angular_core.InputSignal<Record<string, unknown>>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path prefix (e.g., "content") */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Emitted when the block is clicked/focused */
+    readonly selected: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the mouse enters */
+    readonly hoverStart: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the mouse leaves */
+    readonly hoverEnd: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the move up button is clicked */
+    readonly moveUp: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the move down button is clicked */
+    readonly moveDown: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the delete button is clicked */
+    readonly deleteBlock: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the collapse toggle is clicked */
+    readonly toggleCollapse: _angular_core.OutputEmitterRef<void>;
+    /** Visible fields (not hidden by admin config) */
+    readonly visibleFields: _angular_core.Signal<Field[]>;
+    readonly blockAriaLabel: _angular_core.Signal<string>;
+    /** Get a FieldTree sub-node for a block's sub-field */
+    getBlockSubNode(fieldName: string): unknown;
+    /** Get the full path for a block's sub-field */
+    getBlockSubFieldPath(fieldName: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockWrapperComponent, "mcms-block-wrapper", never, { "block": { "alias": "block"; "required": true; "isSignal": true; }; "blockIndex": { "alias": "blockIndex"; "required": true; "isSignal": true; }; "blockConfig": { "alias": "blockConfig"; "required": true; "isSignal": true; }; "blockLabel": { "alias": "blockLabel"; "required": true; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "isHovered": { "alias": "isHovered"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "isCollapsed": { "alias": "isCollapsed"; "required": false; "isSignal": true; }; "canMoveUp": { "alias": "canMoveUp"; "required": false; "isSignal": true; }; "canMoveDown": { "alias": "canMoveDown"; "required": false; "isSignal": true; }; "canDelete": { "alias": "canDelete"; "required": false; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "formTree": { "alias": "formTree"; "required": false; "isSignal": true; }; "formModel": { "alias": "formModel"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "hoverStart": "hoverStart"; "hoverEnd": "hoverEnd"; "moveUp": "moveUp"; "moveDown": "moveDown"; "deleteBlock": "deleteBlock"; "toggleCollapse": "toggleCollapse"; }, never, never, true, never>;
+}
+
+declare class BlockInserterComponent {
+    /** Position where the new block will be inserted */
+    readonly insertIndex: _angular_core.InputSignal<number>;
+    /** Available block type definitions */
+    readonly blockDefinitions: _angular_core.InputSignal<BlockConfig[]>;
+    /** Whether the inserter is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Emitted when a block type is selected */
+    readonly blockTypeSelected: _angular_core.OutputEmitterRef<{
+        blockType: string;
+        atIndex: number;
+    }>;
+    readonly popover: _angular_core.Signal<PopoverTrigger | undefined>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly filteredBlocks: _angular_core.Signal<BlockConfig[]>;
+    selectBlockType(slug: string): void;
+    onPopoverOpened(): void;
+    onPopoverClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockInserterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockInserterComponent, "mcms-block-inserter", never, { "insertIndex": { "alias": "insertIndex"; "required": true; "isSignal": true; }; "blockDefinitions": { "alias": "blockDefinitions"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "blockTypeSelected": "blockTypeSelected"; }, never, never, true, never>;
+}
+
+/** Data passed to the BlockEditDialog via DIALOG_DATA. */
+interface BlockEditDialogData {
+    blockConfig: BlockConfig;
+    formNode: unknown;
+    blockIndex: number;
+    formTree: unknown;
+    formModel: Record<string, unknown>;
+    mode: EntityFormMode;
+    path: string;
+}
+declare class BlockEditDialog {
+    readonly data: BlockEditDialogData;
+    private readonly dialogRef;
+    readonly blockLabel: string;
+    readonly visibleFields: Field[];
+    getFieldNode(fieldName: string): unknown;
+    getFieldPath(fieldName: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockEditDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockEditDialog, "mcms-block-edit-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Dynamic field renderer that switches based on field type.
+ *
+ * Uses Angular Signal Forms bridge pattern: each renderer receives
+ * its formNode (FieldTree) and reads/writes values via FieldState.
+ */
+declare class FieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Root signal forms FieldTree (for layout fields that look up child nodes) */
+    readonly formTree: _angular_core.InputSignal<unknown>;
+    /** Form model data (for condition evaluation and relationship filterOptions) */
+    readonly formModel: _angular_core.InputSignal<Record<string, unknown>>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path (for nested fields) */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Field type for template switching */
+    readonly fieldType: _angular_core.Signal<"number" | "slug" | "email" | "text" | "textarea" | "richText" | "date" | "checkbox" | "select" | "radio" | "password" | "upload" | "relationship" | "array" | "group" | "blocks" | "json" | "point" | "tabs" | "collapsible" | "row">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldRenderer, "mcms-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "formTree": { "alias": "formTree"; "required": false; "isSignal": true; }; "formModel": { "alias": "formModel"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Text field renderer for text and textarea field types.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ */
+declare class TextFieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Placeholder text */
+    readonly placeholder: _angular_core.Signal<string>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Whether to use textarea */
+    readonly isTextarea: _angular_core.Signal<boolean>;
+    /** Input type (text, email, etc.) */
+    readonly inputType: _angular_core.Signal<"email" | "text">;
+    /** Number of rows for textarea */
+    readonly rows: _angular_core.Signal<number>;
+    /** String value from FieldState */
+    readonly stringValue: _angular_core.Signal<string>;
+    /** Field description */
+    readonly description: _angular_core.Signal<string>;
+    /** Max length from field constraints */
+    readonly maxLength: _angular_core.Signal<number | undefined>;
+    /** Current character count */
+    readonly charCount: _angular_core.Signal<number>;
+    /** Whether to show character counter */
+    readonly showCharCount: _angular_core.Signal<boolean>;
+    /** Whether character count exceeds max */
+    readonly charCountExceeded: _angular_core.Signal<boolean>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle value change from input/textarea.
+     */
+    onValueChange(value: string): void;
+    /**
+     * Handle blur from input/textarea.
+     */
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextFieldRenderer, "mcms-text-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Number field renderer.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ *
+ * NOTE: No clamping is applied on value change. Signal forms validators
+ * handle min/max constraint errors. HTML min/max/step attrs still set
+ * for browser-native spinner behavior.
+ */
+declare class NumberFieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Placeholder text */
+    readonly placeholder: _angular_core.Signal<string>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** String value from FieldState */
+    readonly stringValue: _angular_core.Signal<string>;
+    /** Min constraint from field definition */
+    readonly minValue: _angular_core.Signal<number | undefined>;
+    /** Max constraint from field definition */
+    readonly maxValue: _angular_core.Signal<number | undefined>;
+    /** Step constraint from field definition */
+    readonly stepValue: _angular_core.Signal<number | undefined>;
+    /** Range hint text based on min/max/step constraints */
+    readonly rangeHint: _angular_core.Signal<string>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle value change from input.
+     * No clamping — let signal forms validators show min/max errors.
+     */
+    onValueChange(value: string): void;
+    /**
+     * Handle blur from input.
+     */
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberFieldRenderer, "mcms-number-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Select field renderer.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ */
+declare class SelectFieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Placeholder text */
+    readonly placeholder: _angular_core.Signal<string>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Select options (converted to UI SelectOption format with string values) */
+    readonly selectOptions: _angular_core.Signal<SelectOption[]>;
+    /** String value from FieldState */
+    readonly stringValue: _angular_core.Signal<string>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle value change from select.
+     * Marks touched immediately since select has no native blur flow.
+     */
+    onValueChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectFieldRenderer, "mcms-select-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Checkbox field renderer.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ */
+declare class CheckboxFieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Field description */
+    readonly description: _angular_core.Signal<string>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Boolean value from FieldState */
+    readonly boolValue: _angular_core.Signal<boolean>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle value change from checkbox.
+     * Marks touched immediately since checkboxes don't have a native blur flow.
+     */
+    onValueChange(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxFieldRenderer, "mcms-checkbox-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Date field renderer.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ */
+declare class DateFieldRenderer {
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Placeholder text */
+    readonly placeholder: _angular_core.Signal<string>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Input type (date or datetime-local) */
+    readonly inputType: _angular_core.Signal<"text">;
+    /** Formatted date value from FieldState */
+    readonly dateValue: _angular_core.Signal<string>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle value change from input.
+     */
+    onValueChange(value: string): void;
+    /**
+     * Handle blur from input.
+     */
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateFieldRenderer, "mcms-date-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Upload field renderer for file upload fields.
+ * Supports drag & drop, file selection, and media library picking.
+ *
+ * Uses Angular Signal Forms bridge pattern: reads/writes value via
+ * a FieldTree node's FieldState rather than event-based I/O.
+ */
+declare class UploadFieldRenderer {
+    private readonly document;
+    private readonly uploadService;
+    private readonly dialogService;
+    /** Field definition */
+    readonly field: _angular_core.InputSignal<Field>;
+    /** Signal forms FieldTree node for this field */
+    readonly formNode: _angular_core.InputSignal<unknown>;
+    /** Form mode */
+    readonly mode: _angular_core.InputSignal<EntityFormMode>;
+    /** Field path */
+    readonly path: _angular_core.InputSignal<string>;
+    /** Bridge: extract FieldState from formNode */
+    private readonly nodeState;
+    /** Icon references */
+    readonly uploadIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M12 16.5V9.75m0 0 3 3m-3-3-3 3M6.75 19.5a4.5 4.5 0 0 1-1.41-8.775 5.25 5.25 0 0 1 10.233-2.33 3 3 0 0 1 3.758 3.848A3.752 3.752 0 0 1 18 19.5H6.75Z\"></path></svg>";
+    readonly xMarkIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M6 18 18 6M6 6l12 12\"></path></svg>";
+    readonly photoIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\" aria-hidden=\"true\" data-slot=\"icon\" style=\"stroke-width:var(--ng-icon__stroke-width, 1.5)\"><path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"m2.25 15.75 5.159-5.159a2.25 2.25 0 0 1 3.182 0l5.159 5.159m-1.5-1.5 1.409-1.409a2.25 2.25 0 0 1 3.182 0l2.909 2.909m-18 3.75h16.5a1.5 1.5 0 0 0 1.5-1.5V6a1.5 1.5 0 0 0-1.5-1.5H3.75A1.5 1.5 0 0 0 2.25 6v12a1.5 1.5 0 0 0 1.5 1.5Zm10.5-11.25h.008v.008h-.008V8.25Zm.375 0a.375.375 0 1 1-.75 0 .375.375 0 0 1 .75 0Z\"></path></svg>";
+    /** Internal state */
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly uploadProgress: _angular_core.WritableSignal<number>;
+    readonly isUploading: _angular_core.WritableSignal<boolean>;
+    readonly uploadingFilename: _angular_core.WritableSignal<string>;
+    readonly uploadError: _angular_core.WritableSignal<string | null>;
+    readonly uploadingFile: _angular_core.WritableSignal<File | null>;
+    /** Unique field ID */
+    readonly fieldId: _angular_core.Signal<string>;
+    /** Computed label */
+    readonly label: _angular_core.Signal<string>;
+    /** Whether the field is required */
+    readonly required: _angular_core.Signal<boolean>;
+    /** Whether the field is disabled */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Get field as UploadField */
+    readonly uploadField: _angular_core.Signal<UploadField>;
+    /** Current value from FieldState */
+    private readonly currentValue;
+    /** Whether we have a value */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /** Media preview data from value */
+    readonly mediaPreviewData: _angular_core.Signal<MediaPreviewData | null>;
+    /** Media filename from value */
+    readonly mediaFilename: _angular_core.Signal<string>;
+    /** Preview data for file being uploaded */
+    readonly uploadingFilePreview: _angular_core.Signal<MediaPreviewData | null>;
+    /** MIME types hint for display */
+    readonly mimeTypesHint: _angular_core.Signal<string | null>;
+    /** Max size hint for display */
+    readonly maxSizeHint: _angular_core.Signal<string | null>;
+    /** Accept attribute for file input */
+    readonly acceptAttribute: _angular_core.Signal<string>;
+    /** Validation errors shown only when field is touched */
+    readonly touchedErrors: _angular_core.Signal<readonly ValidationError[]>;
+    /**
+     * Handle drag over event.
+     */
+    onDragOver(event: DragEvent): void;
+    /**
+     * Handle drag leave event.
+     */
+    onDragLeave(event: DragEvent): void;
+    /**
+     * Handle file drop.
+     */
+    onDrop(event: DragEvent): void;
+    /**
+     * Trigger hidden file input click.
+     */
+    triggerFileInput(): void;
+    /**
+     * Handle file selection from input.
+     */
+    onFileSelected(event: Event): void;
+    /**
+     * Upload a file.
+     */
+    uploadFile(file: File): void;
+    /**
+     * Open media picker dialog to select existing media.
+     */
+    openMediaPicker(): void;
+    /**
+     * Remove the current media value.
+     */
+    removeMedia(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploadFieldRenderer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UploadFieldRenderer, "mcms-upload-field-renderer", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "formNode": { "alias": "formNode"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Media item from the API.
+ */
+interface MediaItem {
+    id: string;
+    filename: string;
+    mimeType: string;
+    path: string;
+    url?: string;
+    filesize?: number;
+    alt?: string;
+}
+/**
+ * Data passed to the MediaPickerDialog.
+ */
+interface MediaPickerDialogData {
+    /** Allowed MIME types filter */
+    mimeTypes?: string[];
+    /** Collection to query (default: 'media') */
+    relationTo?: string;
+}
+/**
+ * Result returned from the MediaPickerDialog.
+ */
+interface MediaPickerResult {
+    media: MediaItem | null;
+}
+/**
+ * Dialog for selecting media from the media library.
+ */
+declare class MediaPickerDialog {
+    private readonly dialogRef;
+    private readonly data;
+    private readonly api;
+    /** Internal state */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly mediaItems: _angular_core.WritableSignal<MediaItem[]>;
+    readonly selectedMedia: _angular_core.WritableSignal<MediaItem | null>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    readonly totalPages: _angular_core.WritableSignal<number>;
+    readonly totalDocs: _angular_core.WritableSignal<number>;
+    readonly limit: _angular_core.WritableSignal<number>;
+    /** Collection to query */
+    readonly collectionSlug: _angular_core.Signal<string>;
+    constructor();
+    /**
+     * Load media from the API.
+     */
+    private loadMedia;
+    /**
+     * Handle search query change.
+     */
+    onSearchChange(query: string): void;
+    /**
+     * Handle page change.
+     */
+    onPageChange(page: number): void;
+    /**
+     * Select a media item.
+     */
+    selectMedia(media: MediaItem): void;
+    /**
+     * Confirm selection on double-click.
+     */
+    confirmSelection(media: MediaItem): void;
+    /**
+     * Confirm and close dialog.
+     */
+    confirm(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MediaPickerDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MediaPickerDialog, "mcms-media-picker-dialog", never, {}, {}, never, never, true, never>;
+}
+
+export { AdminShellComponent, AdminSidebarWidget, BlockEditDialog, BlockInserterComponent, BlockWrapperComponent, CheckboxFieldRenderer, CollectionAccessService, CollectionCardWidget, CollectionEditPage, CollectionListPage, CollectionViewPage, DashboardPage, DateFieldRenderer, EntityFormWidget, EntityListWidget, EntitySheetService, EntityViewWidget, FeedbackService, FieldRenderer, ForgotPasswordFormComponent, ForgotPasswordPage, LivePreviewComponent, LoginPage, MOMENTUM_API, MOMENTUM_API_CONTEXT, McmsThemeService, MediaLibraryPage, MediaPickerDialog, MediaPreviewComponent, MomentumApiService, MomentumAuthService, NumberFieldRenderer, PublishControlsWidget, ResetPasswordFormComponent, ResetPasswordPage, SHEET_QUERY_PARAMS, SKIP_AUTO_TOAST, SelectFieldRenderer, SetupPage, TextFieldRenderer, UploadFieldRenderer, UploadService, VersionHistoryWidget, VersionService, VisualBlockEditorComponent, adminGuard, authGuard, collectionAccessGuard, crudToastInterceptor, getFieldNodeState, getSubNode, getTitleField, guestGuard, injectHasAnyRole, injectHasRole, injectIsAdmin, injectIsAuthenticated, injectMomentumAPI, injectTypedMomentumAPI, injectUser, injectUserRole, injectVersionService, momentumAdminRoutes, provideMomentumAPI, setupGuard, unsavedChangesGuard };
+export type { AdminBranding, AdminNavItem, AdminNavSection, AdminPluginRoute, AdminUser, AuthResult, AuthSession, AuthUser, BaseUser, BlockEditDialogData, BlockItem, BreadcrumbItem, CollectionPermissions, CollectionWithCount, DeleteResult, DeviceSize, DocumentStatus, DocumentVersionParsed, DraftSaveResult, Entity, EntityAction, EntityFormMode, EntityListActionEvent, EntityListBulkActionEvent, EntityListColumn, EntityListFindResult, EntitySheetResult, EntityViewActionEvent, EntityViewFieldConfig, FieldNodeState, FindByIdOptions, FindOptions, FindResult, HasUnsavedChanges, McmsTheme, MediaPickerDialogData, MediaPickerResult, MediaPreviewData, MomentumAPIContext, MomentumAPIServer, MomentumAdminBranding, MomentumAdminOptions, MomentumAdminRouteData, MomentumClientAPI, MomentumCollectionAPI, PublishResult, RestoreResult, RestoreVersionOptions, SetupStatus, StatusResult, TypedCollectionAPI, TypedFindByIdOptions, TypedFindOptions, TypedMomentumClientAPI, UploadProgress, UserContext, VersionFindOptions, VersionQueryResult, VisualEditorState };