@avora-labs/meta-forge 1.0.5

package/types/avora-labs-meta-forge.d.ts

@@ -0,0 +1,2528 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, OnDestroy, OnChanges, ViewContainerRef, SimpleChanges, OnInit, Signal, EventEmitter, Provider } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Params, Data, CanDeactivateFn, CanActivateFn, Routes, Router } from '@angular/router';
+import { FormGroup, AbstractControl, FormArray } from '@angular/forms';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { SafeHtml } from '@angular/platform-browser';
+import { HttpInterceptorFn } from '@angular/common/http';
+
+/**
+ * AvoraMetaForge — Condition Metadata
+ *
+ * Extended condition system supporting:
+ * - 20+ comparison operators
+ * - Logical grouping (and/or/negate)
+ * - State store references
+ * - Custom evaluator functions
+ * - Date comparisons
+ * - Array operations
+ * - Type checking
+ */
+type ConditionOperator = '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | 'in' | 'notIn' | 'contains' | 'startsWith' | 'endsWith' | 'truthy' | 'falsy' | 'empty' | 'notEmpty' | 'regex' | 'between' | 'notBetween' | 'hasKey' | 'isArray' | 'isObject' | 'isString' | 'isNumber' | 'isNull' | 'isNotNull' | 'lengthEquals' | 'lengthGreaterThan' | 'lengthLessThan' | 'dateBefore' | 'dateAfter' | 'dateEquals' | 'arrayContains' | 'arrayNotContains' | 'matchesAny' | 'matchesAll' | 'custom';
+interface ConditionMeta {
+    /** Field path to evaluate (dot notation for nested, e.g., 'user.role') */
+    field?: string;
+    /** Comparison operator */
+    operator: ConditionOperator;
+    /** Value to compare against. Arrays for 'in', 'between', etc. */
+    value?: any;
+    /** Logical AND — all conditions must be true */
+    and?: ConditionMeta[];
+    /** Logical OR — at least one condition must be true */
+    or?: ConditionMeta[];
+    /** Negate the result */
+    negate?: boolean;
+    /** Custom evaluator function key */
+    custom?: string;
+    /** Source of the field value */
+    source?: 'context' | 'state' | 'route' | 'form' | 'storage';
+    /** For 'between' operator: [min, max] */
+    range?: [any, any];
+    /** Case-insensitive comparison for string operators */
+    caseInsensitive?: boolean;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+
+type FieldType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'textarea' | 'select' | 'multi-select' | 'radio' | 'checkbox' | 'toggle' | 'date' | 'datetime' | 'time' | 'file' | 'color' | 'range' | 'hidden' | 'divider' | 'heading' | 'rich-text' | 'code-editor' | 'auto-complete' | 'tags' | 'rating' | 'slider' | 'switch' | 'image-upload' | 'signature' | 'otp' | 'phone' | 'address' | 'date-range' | 'time-range' | 'currency' | 'percentage' | 'group' | 'repeater' | 'custom';
+type FormLayout = 'vertical' | 'horizontal' | 'grid' | 'inline' | 'stepper';
+interface FormMeta {
+    /** Unique form identifier (used by reset-form, patch-form actions) */
+    id?: string;
+    fields: FieldMeta[];
+    layout?: FormLayout;
+    columns?: number;
+    submitLabel?: string;
+    cancelLabel?: string;
+    resetLabel?: string;
+    showCancel?: boolean;
+    showReset?: boolean;
+    /** Hide the submit button (useful for button-only forms) */
+    hideSubmit?: boolean;
+    /** API endpoint for direct form submission */
+    apiEndpoint?: string;
+    apiMethod?: HttpMethod$1;
+    /** Runs when form initializes (e.g., fetch data for edit mode) */
+    onLoad?: ActionMeta;
+    /** Runs on successful submit */
+    onSubmit?: ActionMeta;
+    /** Runs when cancel is clicked */
+    onCancel?: ActionMeta;
+    /** Runs when reset is clicked */
+    onReset?: ActionMeta;
+    /** Runs whenever any field value changes */
+    onChange?: ActionMeta;
+    /** Runs when form becomes valid */
+    onValid?: ActionMeta;
+    /** Runs when form becomes invalid */
+    onInvalid?: ActionMeta;
+    validators?: ValidatorMeta[];
+    /** Cross-field validators (e.g., password must match confirm) */
+    crossFieldValidators?: CrossFieldValidatorMeta[];
+    /** Pre-populate form values */
+    initialValues?: Record<string, any>;
+    /** Load initial values from API endpoint ID */
+    initialValuesApi?: string;
+    /** Multi-step wizard configuration */
+    steps?: FormStepMeta[];
+    /** Enable autosave */
+    autosave?: AutosaveMeta;
+    /** Warn before navigating away with unsaved changes */
+    confirmUnsaved?: boolean;
+    /** Custom unsaved changes message */
+    unsavedMessage?: string;
+    /** Disable the entire form */
+    disabled?: boolean;
+    /** Make the entire form read-only */
+    readOnly?: boolean;
+    /** CSS class for form container */
+    cssClass?: string;
+    /** Whether to scroll to first error on submit */
+    scrollToError?: boolean;
+    /** Show validation summary at top of form */
+    showValidationSummary?: boolean;
+    /** Whether to validate on field change or on submit only */
+    validateOn?: 'change' | 'blur' | 'submit';
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface FieldMeta {
+    /** Unique key — maps to form control name */
+    key: string;
+    type: FieldType | string;
+    label?: string;
+    description?: string;
+    placeholder?: string;
+    defaultValue?: any;
+    validators?: ValidatorMeta[];
+    options?: OptionMeta[];
+    /** Endpoint ID to load options from API */
+    optionsApi?: string;
+    /** Key in API response to use as label */
+    optionsLabelKey?: string;
+    /** Key in API response to use as value */
+    optionsValueKey?: string;
+    /** Show/hide based on condition */
+    visibleWhen?: ConditionMeta;
+    /** Disable based on condition */
+    disabledWhen?: ConditionMeta;
+    /** Custom component key for rendering */
+    customComponent?: string;
+    cssClass?: string;
+    colSpan?: number;
+    hint?: string;
+    prefix?: string;
+    suffix?: string;
+    readOnly?: boolean;
+    /** Statically disable this field */
+    disabled?: boolean;
+    autocomplete?: string;
+    rows?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    accept?: string;
+    multiple?: boolean;
+    text?: string;
+    /** Action to dispatch when field value changes */
+    onChange?: ActionMeta;
+    /** Action to dispatch when field loses focus */
+    onBlur?: ActionMeta;
+    /** Action to dispatch when field gains focus */
+    onFocus?: ActionMeta;
+    /** Field key this field depends on (cascade selects) */
+    dependsOn?: string;
+    /** API query params derived from dependent field value */
+    dependsOnParams?: Record<string, string>;
+    /** Clear this field when dependent field changes */
+    clearOnDependencyChange?: boolean;
+    /** Input mask pattern (e.g., '(000) 000-0000', '000-00-0000') */
+    mask?: string;
+    /** Mask guide character (default: '_') */
+    maskGuide?: string;
+    /** Derive this field's value from other field values. E.g., 'fullName = firstName + " " + lastName' */
+    computeFrom?: ComputeFieldMeta;
+    /** Make this field required only when condition is met */
+    requiredWhen?: ConditionMeta;
+    /** Fields within a group/repeater */
+    children?: FieldMeta[];
+    /** Min/max items for repeater */
+    minItems?: number;
+    maxItems?: number;
+    /** Label for add button in repeater */
+    addLabel?: string;
+    /** Max file size in bytes */
+    maxFileSize?: number;
+    /** Show upload progress */
+    showProgress?: boolean;
+    /** Max number of files for multi-upload */
+    maxFiles?: number;
+    /** Show image preview */
+    showPreview?: boolean;
+    /** Drag and drop upload */
+    dragDrop?: boolean;
+    /** Button color variant */
+    color?: string;
+    /** Button style variant */
+    variant?: string;
+    /** Action to dispatch when button is clicked */
+    onClick?: ActionMeta;
+    /** Custom HTML attributes */
+    customAttributes?: Record<string, string>;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface ValidatorMeta {
+    type: 'required' | 'minLength' | 'maxLength' | 'min' | 'max' | 'pattern' | 'email' | 'url' | 'number' | 'integer' | 'match' | 'notMatch' | 'unique' | 'fileType' | 'fileSize' | 'dateRange' | 'custom' | string;
+    value?: any;
+    /** Custom error message */
+    message?: string;
+    /** Custom validator function key */
+    custom?: string;
+    /** Field key for 'match'/'notMatch' validators */
+    matchField?: string;
+    /** Validate only when this condition is met */
+    when?: ConditionMeta;
+}
+interface CrossFieldValidatorMeta {
+    type: 'match' | 'dateOrder' | 'atLeastOne' | 'custom' | string;
+    /** Fields involved */
+    fields: string[];
+    message: string;
+    custom?: string;
+    [key: string]: any;
+}
+interface OptionMeta {
+    label: string;
+    value: any;
+    disabled?: boolean;
+    icon?: string;
+    group?: string;
+    description?: string;
+    color?: string;
+    [key: string]: any;
+}
+interface FormStepMeta {
+    /** Step title */
+    title: string;
+    /** Step description / subtitle */
+    description?: string;
+    /** Step icon */
+    icon?: string;
+    /** Field keys included in this step */
+    fields: string[];
+    /** Validate before allowing next step */
+    validate?: boolean;
+    /** Action to run when entering this step */
+    onEnter?: ActionMeta;
+    /** Action to run when leaving this step */
+    onLeave?: ActionMeta;
+    /** Condition to skip this step */
+    skipWhen?: ConditionMeta;
+    /** Whether the step can be manually skipped */
+    optional?: boolean;
+}
+interface AutosaveMeta {
+    /** Debounce delay in milliseconds */
+    debounceMs: number;
+    /** API endpoint to auto-save to */
+    endpointId?: string;
+    /** Action to dispatch on autosave */
+    action?: ActionMeta;
+    /** Show save indicator */
+    showIndicator?: boolean;
+}
+interface ComputeFieldMeta {
+    /** Field keys to watch */
+    watch: string[];
+    /** Expression template. E.g., '{{firstName}} {{lastName}}' */
+    expression?: string;
+    /** Custom compute function key */
+    custom?: string;
+}
+
+type CellType = 'text' | 'badge' | 'avatar' | 'date' | 'datetime' | 'currency' | 'number' | 'boolean' | 'link' | 'image' | 'progress' | 'actions' | 'icon' | 'color' | 'rating' | 'tags' | 'truncate' | 'html' | 'template' | 'time-ago' | 'file-size' | 'phone' | 'email' | 'url' | 'json' | 'copy' | 'editable' | 'select' | 'toggle' | 'custom';
+interface TableMeta {
+    /** Unique table identifier (used by reload-table action) */
+    id?: string;
+    columns: ColumnMeta[];
+    dataSource: 'api' | 'static' | 'signal';
+    apiEndpoint?: string;
+    /** Endpoint ID registered in the API service (for mock or real endpoints) */
+    endpointId?: string;
+    staticData?: any[];
+    pagination?: PaginationMeta;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    searchFields?: string[];
+    filterable?: boolean;
+    sortable?: boolean;
+    defaultSortKey?: string;
+    defaultSortDirection?: 'asc' | 'desc';
+    actions?: TableActionMeta[];
+    bulkActions?: TableActionMeta[];
+    rowClick?: ActionMeta;
+    emptyMessage?: string;
+    selectable?: boolean;
+    showRowNumbers?: boolean;
+    title?: string;
+    headerActions?: TableActionMeta[];
+    filters?: TableFilterMeta[];
+    cssClass?: string;
+    variant?: 'default' | 'striped' | 'borderless' | 'glass' | 'elevated' | 'compact' | string;
+    /** Bump this number to bust the sessionStorage cache and re-seed from staticData */
+    dataVersion?: number;
+    striped?: boolean;
+    hoverable?: boolean;
+    /** Enable server-side pagination, sort, and filter */
+    serverSide?: boolean;
+    /** API pagination config (query param names, response paths) */
+    serverPagination?: ServerPaginationConfig;
+    /** Enable data export */
+    exportable?: boolean;
+    /** Supported export formats */
+    exportFormats?: ('csv' | 'json' | 'xlsx' | 'pdf')[];
+    /** Custom export filename (without extension) */
+    exportFilename?: string;
+    /** Columns to include in export (keys). If omitted, exports all visible */
+    exportColumns?: string[];
+    /** Enable inline row editing */
+    inlineEdit?: boolean;
+    /** Action to dispatch when an inline edit is saved */
+    onInlineEditSave?: ActionMeta;
+    /** Action to dispatch when an inline edit is cancelled */
+    onInlineEditCancel?: ActionMeta;
+    /** Enable row expansion (detail sub-row) */
+    expandable?: boolean;
+    /** Component key to render in expanded area */
+    expandComponent?: string;
+    /** Section to render in expanded area (alternative to component) */
+    expandSection?: SectionMeta;
+    /** Only allow one expanded row at a time */
+    singleExpand?: boolean;
+    /** Enable virtual scroll for large datasets */
+    virtualScroll?: boolean;
+    /** Row height for virtual scroll calculation */
+    rowHeight?: number;
+    /** Enable infinite scroll (load more on scroll) */
+    infiniteScroll?: boolean;
+    /** API endpoint for loading next page in infinite scroll */
+    loadMoreEndpoint?: string;
+    /** Show column visibility toggle */
+    columnToggle?: boolean;
+    /** Allow column reorder via drag */
+    columnReorder?: boolean;
+    /** Allow column resize via drag */
+    columnResize?: boolean;
+    /** Enable row drag-to-reorder */
+    reorderable?: boolean;
+    /** Action when row order changes */
+    onReorder?: ActionMeta;
+    /** Enable multi-column sort */
+    multiSort?: boolean;
+    /** Sticky header on scroll */
+    stickyHeader?: boolean;
+    /** Group rows by this column key */
+    groupBy?: string;
+    /** Collapsible groups */
+    groupCollapsible?: boolean;
+    /** Start groups collapsed */
+    groupCollapsed?: boolean;
+    /** Aggregate row configuration (footer totals) */
+    aggregates?: AggregateRowMeta[];
+    /** Selection mode */
+    selectionMode?: 'single' | 'multi' | 'checkbox';
+    /** Action when selection changes */
+    onSelectionChange?: ActionMeta;
+    /** Show "Select All" checkbox */
+    showSelectAll?: boolean;
+    /** Conditionally style rows based on data */
+    rowClass?: RowClassMeta[];
+    /** Row context menu (right-click) */
+    contextMenu?: TableActionMeta[];
+    /** Action on data load complete */
+    onDataLoad?: ActionMeta;
+    /** Action on data load error */
+    onDataError?: ActionMeta;
+    /** Refresh interval (ms) — auto-reload data periodically */
+    refreshInterval?: number;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface ColumnMeta {
+    key: string;
+    label: string;
+    type?: CellType | string;
+    sortable?: boolean;
+    filterable?: boolean;
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    align?: 'left' | 'center' | 'right';
+    template?: string;
+    pipe?: string;
+    cssClass?: string;
+    badgeMap?: Record<string, string>;
+    avatarKey?: string;
+    subtitleKey?: string;
+    linkRoute?: string;
+    currencyCode?: string;
+    currencyDisplay?: string | boolean;
+    currencyCodeKey?: string;
+    dateFormat?: string;
+    visibleWhen?: ConditionMeta;
+    hidden?: boolean;
+    /** Pin/freeze column to left or right */
+    pin?: 'left' | 'right';
+    /** Column is resizable */
+    resizable?: boolean;
+    /** Column is reorderable */
+    reorderable?: boolean;
+    /** Tooltip text or template */
+    tooltip?: string;
+    /** Cell-level click action */
+    cellClick?: ActionMeta;
+    /** Wrap text in cell */
+    wrap?: boolean;
+    /** Max truncation length */
+    truncateAt?: number;
+    /** Header tooltip */
+    headerTooltip?: string;
+    /** Editable configuration (for inline edit) */
+    editable?: boolean;
+    editType?: 'text' | 'number' | 'select' | 'date' | 'toggle';
+    editOptions?: {
+        label: string;
+        value: any;
+    }[];
+    /** Cell format function key (for custom formatting) */
+    format?: string;
+    /** Aggregate function for this column */
+    aggregate?: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'custom';
+    aggregateLabel?: string;
+    /** Validators applied to inline-edit input before committing */
+    editValidators?: ColumnEditValidatorMeta[];
+    /** Catch-all */
+    [key: string]: any;
+}
+interface PaginationMeta {
+    enabled: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showPageSizeSelector?: boolean;
+    showTotal?: boolean;
+    /** Show first/last page buttons */
+    showFirstLast?: boolean;
+    /** Max page buttons to show */
+    maxPages?: number;
+    /** Show "Showing X-Y of Z" text */
+    showRange?: boolean;
+}
+interface ServerPaginationConfig {
+    /** Query param name for page number (default: 'page') */
+    pageParam?: string;
+    /** Query param name for page size (default: 'size') */
+    sizeParam?: string;
+    /** Query param name for sort field (default: 'sort') */
+    sortParam?: string;
+    /** Query param name for sort direction (default: 'direction') */
+    directionParam?: string;
+    /** Query param name for search (default: 'search') */
+    searchParam?: string;
+    /** Query param name for filter (default uses filter key) */
+    filterParams?: Record<string, string>;
+    /** Path in response to data array (default: 'data') */
+    dataPath?: string;
+    /** Path in response to total count (default: 'total') */
+    totalPath?: string;
+    /** Path in response to total pages */
+    totalPagesPath?: string;
+}
+interface TableActionMeta {
+    id: string;
+    label: string;
+    icon?: string;
+    variant?: 'primary' | 'secondary' | 'danger' | 'ghost' | 'success' | 'warning' | string;
+    action: ActionMeta;
+    visibleWhen?: ConditionMeta;
+    disabledWhen?: ConditionMeta;
+    confirm?: string;
+    /** Tooltip for the action button */
+    tooltip?: string;
+    /** Show as dropdown menu item instead of inline button */
+    menuItem?: boolean;
+    /** Keyboard shortcut hint */
+    shortcut?: string;
+    [key: string]: any;
+}
+interface TableFilterMeta {
+    key: string;
+    label: string;
+    type?: 'select' | 'text' | 'date' | 'date-range' | 'number-range' | 'multi-select' | 'toggle';
+    options?: {
+        label: string;
+        value: any;
+    }[];
+    defaultValue?: any;
+    placeholder?: string;
+    /** For server-side: query param name */
+    queryParam?: string;
+}
+interface AggregateRowMeta {
+    /** Column key to aggregate */
+    columnKey: string;
+    /** Aggregate function */
+    type: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'custom';
+    /** Display label */
+    label?: string;
+    /** Format (e.g., currency, percentage) */
+    format?: string;
+    /** Custom aggregate function key */
+    custom?: string;
+}
+interface RowClassMeta {
+    /** Condition to evaluate for each row */
+    condition: ConditionMeta;
+    /** CSS class to apply when condition is true */
+    cssClass: string;
+}
+interface ColumnEditValidatorMeta {
+    type: 'required' | 'minLength' | 'maxLength' | 'min' | 'max' | 'pattern' | 'email' | 'number' | string;
+    /** Validator parameter (e.g., minLength: 3, pattern: '^[A-Z]') */
+    value?: any;
+    /** Custom error message shown below the inline input */
+    message?: string;
+}
+
+/**
+ * AvoraMetaForge — Section Metadata
+ *
+ * Sections are the building blocks within a page. Each section has a type
+ * and configuration. Extended with new section types for drawers, modals,
+ * tabs, accordions, and more.
+ */
+
+interface SectionMeta {
+    type: 'form' | 'table' | 'card' | 'stats-grid' | 'page-header' | 'html' | 'stepper-form' | 'tabs' | 'accordion' | 'timeline' | 'steps' | 'chart' | 'map' | 'calendar' | 'kanban' | 'tree' | 'gallery' | 'markdown' | 'iframe' | 'divider' | 'spacer' | 'alert' | 'empty-state' | 'skeleton' | 'custom' | string;
+    config: FormMeta | TableMeta | CardMeta | StatsGridMeta | PageHeaderMeta | HtmlMeta | TabsMeta | AccordionMeta | TimelineMeta | AlertMeta | EmptyStateMeta | IframeMeta | DividerMeta | SpacerMeta | Record<string, any>;
+    /** Section ID (referenced by actions like reload-table, reset-form) */
+    id?: string;
+    visibleWhen?: ConditionMeta;
+    cssClass?: string;
+    style?: Record<string, string>;
+    gridArea?: string;
+    gridColumn?: string;
+    gridRow?: string;
+    /** Section title (rendered as a header above the section) */
+    title?: string;
+    /** Section subtitle */
+    subtitle?: string;
+    /** Collapsible section */
+    collapsible?: boolean;
+    /** Start collapsed */
+    collapsed?: boolean;
+    /** Section-level loading state */
+    loading?: boolean;
+    /** Action to dispatch when section becomes visible (lazy-load) */
+    onVisible?: ActionMeta;
+    /** Animation for section entrance */
+    animation?: 'fade-in' | 'slide-up' | 'slide-left' | 'zoom-in' | 'none' | string;
+    /** Animation delay (ms) */
+    animationDelay?: number;
+    /** Catch-all */
+    [key: string]: any;
+}
+interface PageHeaderMeta {
+    title: string;
+    subtitle?: string;
+    titleTemplate?: string;
+    actions?: PageHeaderActionMeta[];
+    showBack?: boolean;
+    /** Breadcrumbs in header */
+    breadcrumbs?: {
+        label: string;
+        path?: string;
+    }[];
+    /** Avatar/icon next to title */
+    avatar?: string;
+    /** Status badge */
+    status?: {
+        label: string;
+        color: string;
+    };
+    [key: string]: any;
+}
+interface PageHeaderActionMeta {
+    label: string;
+    icon?: string;
+    variant?: 'primary' | 'secondary' | 'ghost' | 'danger' | 'success' | string;
+    action: ActionMeta;
+    visibleWhen?: ConditionMeta;
+    disabledWhen?: ConditionMeta;
+    tooltip?: string;
+    /** Show as dropdown menu */
+    children?: PageHeaderActionMeta[];
+}
+interface CardMeta {
+    title?: string;
+    content?: string;
+    template?: string;
+    actions?: PageHeaderActionMeta[];
+    variant?: 'default' | 'glass' | 'outlined' | 'elevated' | 'gradient' | string;
+    /** Card header icon */
+    icon?: string;
+    /** Image at top of card */
+    image?: string;
+    /** Footer content */
+    footer?: string;
+    /** Click action on the card */
+    onClick?: ActionMeta;
+    /** Nested sections inside the card */
+    sections?: SectionMeta[];
+    [key: string]: any;
+}
+interface StatsGridMeta {
+    stats: StatCardMeta[];
+    columns?: number;
+    variant?: 'default' | 'glass' | 'compact' | 'outlined' | 'elevated' | string;
+    [key: string]: any;
+}
+interface StatCardMeta {
+    label: string;
+    value: string;
+    trend?: string;
+    trendPositive?: boolean;
+    icon?: string;
+    color?: string;
+    bgColor?: string;
+    glowColor?: string;
+    action?: ActionMeta;
+    /** Sparkline data points */
+    sparkline?: number[];
+    /** Suffix text (e.g., '%', 'users') */
+    suffix?: string;
+    /** Prefix text (e.g., '$') */
+    prefix?: string;
+    /** Load value from API endpoint */
+    apiEndpoint?: string;
+    [key: string]: any;
+}
+interface HtmlMeta {
+    html: string;
+    /** Sanitize HTML (default: true) */
+    sanitize?: boolean;
+}
+interface CustomComponentMeta {
+    componentKey: string;
+    inputs?: Record<string, any>;
+    outputs?: Record<string, ActionMeta>;
+    [key: string]: any;
+}
+interface TabsMeta {
+    tabs: TabMeta[];
+    variant?: 'default' | 'pills' | 'underline' | 'vertical' | string;
+    defaultTab?: number;
+    /** Lazy load tab content */
+    lazy?: boolean;
+    /** Action when tab changes */
+    onChange?: ActionMeta;
+}
+interface TabMeta {
+    label: string;
+    icon?: string;
+    badge?: string;
+    sections: SectionMeta[];
+    visibleWhen?: ConditionMeta;
+    disabled?: boolean;
+}
+interface AccordionMeta {
+    panels: AccordionPanelMeta[];
+    /** Allow multiple panels open */
+    multi?: boolean;
+    variant?: 'default' | 'bordered' | 'flush' | string;
+}
+interface AccordionPanelMeta {
+    title: string;
+    icon?: string;
+    sections: SectionMeta[];
+    expanded?: boolean;
+    visibleWhen?: ConditionMeta;
+    disabled?: boolean;
+}
+interface TimelineMeta {
+    items: TimelineItemMeta[];
+    variant?: 'default' | 'alternating' | 'compact' | string;
+    /** Load items from API */
+    apiEndpoint?: string;
+}
+interface TimelineItemMeta {
+    title: string;
+    description?: string;
+    date?: string;
+    icon?: string;
+    color?: string;
+    action?: ActionMeta;
+    [key: string]: any;
+}
+interface AlertMeta {
+    type: 'info' | 'success' | 'warning' | 'error';
+    title?: string;
+    message: string;
+    dismissible?: boolean;
+    icon?: string;
+    action?: ActionMeta;
+    actionLabel?: string;
+}
+interface EmptyStateMeta {
+    icon?: string;
+    title: string;
+    description?: string;
+    action?: ActionMeta;
+    actionLabel?: string;
+    image?: string;
+}
+interface IframeMeta {
+    src: string;
+    height?: string;
+    width?: string;
+    allowFullscreen?: boolean;
+    sandbox?: string;
+    title?: string;
+}
+interface DividerMeta {
+    label?: string;
+    variant?: 'solid' | 'dashed' | 'dotted';
+    color?: string;
+    spacing?: string;
+}
+interface SpacerMeta {
+    height?: string;
+}
+
+/**
+ * AvoraMetaForge — Action Metadata
+ *
+ * Comprehensive action system supporting 25+ action types covering:
+ * - Navigation, API calls, UI state, modals/drawers
+ * - Form manipulation, table control, clipboard, downloads
+ * - State management, storage, conditional branching, scripting
+ * - Parallel dispatch, delay, logging, context transforms
+ */
+/** HTTP methods — all standard methods supported */
+type HttpMethod$1 = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/** All built-in action types */
+type ActionType = 'navigate' | 'api' | 'notify' | 'emit' | 'confirm' | 'open-modal' | 'close-modal' | 'open-drawer' | 'close-drawer' | 'set-state' | 'clear-state' | 'reset-form' | 'patch-form' | 'submit-form' | 'reload-table' | 'scroll-to' | 'set-loading' | 'clear-loading' | 'download-file' | 'copy-to-clipboard' | 'open-url' | 'set-storage' | 'remove-storage' | 'dispatch-multiple' | 'delay' | 'conditional' | 'for-each' | 'transform-context' | 'log' | 'print' | 'focus' | 'blur' | 'toggle-class' | 'set-title' | 'go-back' | 'go-forward' | 'reload-page' | 'store-data' | 'custom';
+/**
+ * Represents a declarative action that the framework can execute.
+ * Actions are chainable via `then` and `onError`, and can fan-out via `dispatch-multiple`.
+ */
+interface ActionMeta {
+    /** The action type — built-in or custom string */
+    type: ActionType | string;
+    /** Configuration object — shape depends on `type` */
+    config: NavigateActionConfig | ApiActionConfig | NotifyActionConfig | EmitActionConfig | ConfirmActionConfig | ModalActionConfig | DrawerActionConfig | SetStateActionConfig | ClearStateActionConfig | ResetFormActionConfig | PatchFormActionConfig | SubmitFormActionConfig | ReloadTableActionConfig | ScrollToActionConfig | LoadingActionConfig | DownloadFileActionConfig | CopyToClipboardActionConfig | OpenUrlActionConfig | StorageActionConfig | DispatchMultipleActionConfig | DelayActionConfig | ConditionalActionConfig | ForEachActionConfig | TransformContextActionConfig | LogActionConfig | PrintActionConfig | FocusActionConfig | ToggleClassActionConfig | SetTitleActionConfig | Record<string, any>;
+    /** Action to execute after this one succeeds */
+    then?: ActionMeta;
+    /** Action to execute if this one fails */
+    onError?: ActionMeta;
+    /** Human-readable description for devtools / debugging */
+    description?: string;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface NavigateActionConfig {
+    path: string;
+    params?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    replaceUrl?: boolean;
+    fragment?: string;
+    relativeTo?: boolean;
+    skipLocationChange?: boolean;
+    /** Pass state data via navigation extras */
+    state?: Record<string, any>;
+}
+interface ApiActionConfig {
+    /** Reference to registered endpoint by ID */
+    endpointId?: string;
+    /** Inline URL (alternative to endpointId) */
+    url?: string;
+    method?: HttpMethod$1;
+    body?: Record<string, any> | string | 'formValue';
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    /** Response type control */
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    /** Store response in context under this key */
+    storeResultAs?: string;
+    /** Store response in MetaStateService under this key */
+    storeInState?: string;
+    /** Map status codes to error actions */
+    errorMap?: Record<number, ActionMeta>;
+    /** Use mock data instead of live call */
+    mock?: boolean;
+    mockData?: any;
+}
+interface NotifyActionConfig {
+    type: 'success' | 'error' | 'warning' | 'info';
+    message: string;
+    title?: string;
+    duration?: number;
+    dismissible?: boolean;
+    /** Action to run when notification is clicked */
+    onClick?: ActionMeta;
+}
+interface EmitActionConfig {
+    event: string;
+    payload?: any;
+    /** Whether to include current context as payload automatically */
+    includeContext?: boolean;
+}
+interface ConfirmActionConfig {
+    title?: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: 'info' | 'warning' | 'danger';
+    onConfirm: ActionMeta;
+    onCancel?: ActionMeta;
+}
+interface ModalActionConfig {
+    modalId?: string;
+    title?: string;
+    /** Section to render inside the modal */
+    section?: SectionMeta;
+    /** Custom component key to render */
+    componentKey?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    closable?: boolean;
+    data?: Record<string, any>;
+    onClose?: ActionMeta;
+}
+interface DrawerActionConfig {
+    drawerId?: string;
+    title?: string;
+    section?: SectionMeta;
+    componentKey?: string;
+    position?: 'left' | 'right';
+    width?: string;
+    closable?: boolean;
+    data?: Record<string, any>;
+    onClose?: ActionMeta;
+}
+interface SetStateActionConfig {
+    key: string;
+    /** Value to set — can be literal or 'fromContext:path.to.value' */
+    value: any;
+    /** Merge with existing value (for objects) instead of replacing */
+    merge?: boolean;
+    /** Persist to localStorage */
+    persist?: boolean;
+}
+interface ClearStateActionConfig {
+    key: string;
+    /** Clear from persistence too */
+    clearPersisted?: boolean;
+}
+interface ResetFormActionConfig {
+    /** ID of the form to reset — matches SectionMeta id or form container */
+    formId?: string;
+    /** Reset to initial values instead of empty */
+    toInitialValues?: boolean;
+}
+interface PatchFormActionConfig {
+    formId?: string;
+    /** Key-value pairs to patch into the form */
+    values: Record<string, any>;
+    /** If true, values come from state store keys */
+    fromState?: boolean;
+}
+interface SubmitFormActionConfig {
+    formId?: string;
+    /** Force submit even if invalid */
+    force?: boolean;
+}
+interface ReloadTableActionConfig {
+    tableId?: string;
+    /** Reset page to 1 on reload */
+    resetPage?: boolean;
+    /** Clear search/filter on reload */
+    clearFilters?: boolean;
+}
+interface ScrollToActionConfig {
+    /** CSS selector or element ID */
+    target?: string;
+    /** Pixel offset from top */
+    top?: number;
+    behavior?: 'smooth' | 'instant' | 'auto';
+    block?: 'start' | 'center' | 'end' | 'nearest';
+}
+interface LoadingActionConfig {
+    /** Loading key (allows multiple concurrent loaders) */
+    key?: string;
+    message?: string;
+}
+interface FocusActionConfig {
+    /** CSS selector or element ID */
+    target: string;
+}
+interface ToggleClassActionConfig {
+    /** CSS selector or element ID */
+    target: string;
+    className: string;
+    action: 'add' | 'remove' | 'toggle';
+}
+interface SetTitleActionConfig {
+    title: string;
+}
+interface DownloadFileActionConfig {
+    /** URL to download from */
+    url?: string;
+    /** Endpoint ID to call (returns blob) */
+    endpointId?: string;
+    /** Filename for the downloaded file */
+    filename?: string;
+    /** MIME type hint */
+    mimeType?: string;
+    /** Content to download as string (for generated files) */
+    content?: string;
+}
+interface CopyToClipboardActionConfig {
+    /** Literal text, or 'fromContext:path.to.value' to extract from context */
+    text: string;
+    /** Notification on success */
+    successMessage?: string;
+}
+interface OpenUrlActionConfig {
+    url: string;
+    target?: '_blank' | '_self' | '_parent' | '_top';
+    features?: string;
+}
+interface StorageActionConfig {
+    storage: 'local' | 'session';
+    key: string;
+    /** Value to store. 'fromContext:path' to extract from context */
+    value?: any;
+}
+interface DispatchMultipleActionConfig {
+    actions: ActionMeta[];
+    /** Run in parallel or sequentially */
+    mode?: 'parallel' | 'sequential';
+    /** Stop on first error (sequential mode only) */
+    stopOnError?: boolean;
+}
+interface DelayActionConfig {
+    /** Delay in milliseconds */
+    duration: number;
+}
+interface ConditionalActionConfig {
+    condition: ConditionMeta;
+    onTrue: ActionMeta;
+    onFalse?: ActionMeta;
+}
+interface ForEachActionConfig {
+    /** Path in context to the array to iterate */
+    items: string;
+    /** Action to dispatch per item. Item is available as context.item */
+    action: ActionMeta;
+    /** Run in parallel or sequentially */
+    mode?: 'parallel' | 'sequential';
+}
+interface TransformContextActionConfig {
+    /** Map of new context keys to source paths */
+    map: Record<string, string>;
+    /** If true, merge with existing context. If false, replace */
+    merge?: boolean;
+}
+interface LogActionConfig {
+    level?: 'log' | 'info' | 'warn' | 'error' | 'debug';
+    message?: string;
+    /** Log the full context */
+    logContext?: boolean;
+    /** Specific path in context to log */
+    path?: string;
+}
+interface PrintActionConfig {
+    /** CSS selector to print. If omitted, prints whole page */
+    target?: string;
+    title?: string;
+}
+
+/**
+ * AvoraMetaForge — Guard & Resolver Metadata
+ *
+ * Extended with:
+ * - canDeactivate support
+ * - Token refresh hints
+ * - Per-endpoint auth override
+ * - Permission-based guards
+ * - IP/geo restrictions
+ * - Time-based access
+ */
+
+interface GuardMeta {
+    /** Require authentication */
+    requireAuth?: boolean;
+    /** Required roles (user must have at least one) */
+    roles?: string[];
+    /** Required permissions (user must have ALL) */
+    permissions?: string[];
+    /** Redirect path when guard fails */
+    redirectTo?: string;
+    /** Custom guard function key */
+    custom?: string;
+    /** Condition-based guard */
+    condition?: ConditionMeta;
+    /** Action to dispatch on guard failure (alternative to redirect) */
+    onFail?: ActionMeta;
+    /** Show a notification on guard failure */
+    failMessage?: string;
+    /** Can deactivate guard (show unsaved changes warning) */
+    canDeactivate?: boolean;
+    /** Custom deactivation message */
+    deactivateMessage?: string;
+    /** Feature flag key — page accessible only if flag is on */
+    featureFlag?: string;
+    /** Time-based access window */
+    accessWindow?: {
+        from?: string;
+        to?: string;
+        timezone?: string;
+    };
+    /** Catch-all */
+    [key: string]: any;
+}
+interface ResolverMeta {
+    /** Data source */
+    source: 'api' | 'static' | 'state' | 'custom';
+    /** API endpoint ID to resolve from */
+    endpointId?: string;
+    /** Direct URL (alternative to endpointId) */
+    url?: string;
+    /** Params to pass (supports :param references from route) */
+    params?: Record<string, string>;
+    /** Static data to resolve */
+    staticData?: any;
+    /** State key to read from MetaStateService */
+    stateKey?: string;
+    /** Custom resolver function key */
+    custom?: string;
+    /** Transform the resolved data */
+    transform?: {
+        root?: string;
+        map?: Record<string, string>;
+    };
+    /** Key to store resolved data under in route data */
+    key?: string;
+    /** Show loading indicator while resolving */
+    showLoading?: boolean;
+    /** Action on resolve failure */
+    onError?: ActionMeta;
+    /** Catch-all */
+    [key: string]: any;
+}
+
+/**
+ * AvoraMetaForge — API Metadata
+ *
+ * Comprehensive API endpoint configuration supporting:
+ * - All HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+ * - Auth strategies (Bearer, Basic, API Key, custom)
+ * - Response transforms, caching, retry with exponential backoff
+ * - Mock mode for development/testing without a backend
+ * - Timeout, abort, response type control
+ * - Status code → action error mapping
+ * - Environment-based base URL overrides
+ * - File upload (multipart/form-data) support
+ * - Pagination hints for server-side pagination
+ */
+
+interface ApiEndpointMeta {
+    /** Unique identifier for this endpoint */
+    id: string;
+    /** Base URL (e.g., 'https://api.example.com'). Can be overridden by environment config */
+    baseUrl?: string;
+    /** Path template (e.g., '/users/:id/posts'). Supports :param placeholders */
+    path: string;
+    /** HTTP method */
+    method: HttpMethod$1;
+    /** Static headers merged with default headers */
+    headers?: Record<string, string>;
+    /** Static path/query params merged with dynamic params */
+    params?: Record<string, string>;
+    /** Static request body — can be overridden dynamically */
+    body?: Record<string, any> | string;
+    /** Response transform pipeline */
+    transform?: TransformMeta;
+    /** Response caching configuration */
+    cache?: CacheMeta;
+    /** Retry configuration */
+    retry?: RetryMeta;
+    /** Custom error handler key */
+    errorHandler?: string;
+    /** Authentication strategy for this endpoint */
+    auth?: ApiAuthMeta;
+    /** Timeout in milliseconds. 0 = no timeout */
+    timeout?: number;
+    /** Content type override. Default: 'application/json' */
+    contentType?: 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded' | 'text/plain' | string;
+    /** Expected response type */
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    /** If true, show loading indicator during this call */
+    showLoading?: boolean;
+    /** Loading message to display */
+    loadingMessage?: string;
+    /** Map HTTP status codes to specific actions */
+    errorMap?: Record<number, ActionMeta>;
+    /** Default error notification message */
+    errorMessage?: string;
+    /** Suppress automatic error notifications */
+    silentErrors?: boolean;
+    /** If true, return mockData without making a real HTTP call */
+    mock?: boolean;
+    /** Static data to return in mock mode */
+    mockData?: any;
+    /** Simulated delay (ms) in mock mode */
+    mockDelay?: number;
+    /** Simulated error in mock mode */
+    mockError?: {
+        status: number;
+        message: string;
+    };
+    /** Pagination configuration for server-side pagination */
+    pagination?: ApiPaginationMeta;
+    /** Environment key to resolve baseUrl from config (e.g., 'production', 'staging') */
+    environment?: string;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface ApiAuthMeta {
+    /** Auth strategy */
+    type: 'bearer' | 'basic' | 'apiKey' | 'custom' | 'none';
+    /** For bearer: the token string or state key (e.g., 'state:auth.token') */
+    token?: string;
+    /** For basic: username */
+    username?: string;
+    /** For basic: password  */
+    password?: string;
+    /** For apiKey: header name (e.g., 'X-API-Key') */
+    headerName?: string;
+    /** For apiKey: the key value or state key */
+    apiKey?: string;
+    /** For custom: header name and value */
+    customHeader?: {
+        name: string;
+        value: string;
+    };
+    /** Whether to skip auth for this specific endpoint (override global) */
+    skip?: boolean;
+}
+interface TransformMeta {
+    /** Dot-notation path to unwrap (e.g., 'data.results') */
+    root?: string;
+    /** Map response keys (target ← source). Applied per item if array */
+    map?: Record<string, string>;
+    /** Custom transform function key */
+    custom?: string;
+    /** Flatten nested objects */
+    flatten?: boolean;
+    /** Pick only these keys from the response */
+    pick?: string[];
+    /** Omit these keys from the response */
+    omit?: string[];
+    /** Sort the response array */
+    sort?: {
+        key: string;
+        direction?: 'asc' | 'desc';
+    };
+}
+interface CacheMeta {
+    /** Enable caching for this endpoint */
+    enabled: boolean;
+    /** Time-to-live in milliseconds */
+    ttl?: number;
+    /** Custom cache key. If omitted, auto-generated from URL + params */
+    key?: string;
+    /** Cache storage: memory (default), sessionStorage, localStorage */
+    storage?: 'memory' | 'session' | 'local';
+    /** If true, return stale data while revalidating (SWR pattern) */
+    staleWhileRevalidate?: boolean;
+    /** Invalidate cache when these endpoint IDs are called successfully */
+    invalidateOn?: string[];
+}
+interface RetryMeta {
+    /** Maximum number of retry attempts */
+    maxRetries: number;
+    /** Initial delay between retries (ms) */
+    delay?: number;
+    /** Use exponential backoff */
+    exponential?: boolean;
+    /** Only retry on these HTTP status codes */
+    retryOn?: number[];
+    /** Do NOT retry on these status codes */
+    skipOn?: number[];
+    /** Maximum total delay cap (ms) */
+    maxDelay?: number;
+}
+interface ApiPaginationMeta {
+    /** Query param name for page number */
+    pageParam?: string;
+    /** Query param name for page size */
+    sizeParam?: string;
+    /** Query param name for sort field */
+    sortParam?: string;
+    /** Query param name for sort direction */
+    directionParam?: string;
+    /** Query param name for search term */
+    searchParam?: string;
+    /** Path in response to the data array */
+    dataPath?: string;
+    /** Path in response to total count */
+    totalPath?: string;
+    /** Path in response to total pages */
+    totalPagesPath?: string;
+}
+
+/**
+ * AvoraMetaForge — Plugin Metadata
+ *
+ * Extended plugin system with lifecycle hooks, interceptors,
+ * custom transforms, and more extension points.
+ */
+
+interface AvoraMetaForgePlugin {
+    /** Unique plugin name */
+    name: string;
+    /** Plugin version */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /** Custom section components (rendered by MetaRendererComponent) */
+    components?: Record<string, Type<any>>;
+    /** Custom validator functions */
+    validators?: Record<string, (...args: any[]) => any>;
+    /** Custom guard functions */
+    guards?: Record<string, (...args: any[]) => any>;
+    /** Custom field type components */
+    fieldTypes?: Record<string, Type<any>>;
+    /** Custom cell type components */
+    cellTypes?: Record<string, Type<any>>;
+    /** Custom condition evaluators */
+    conditions?: Record<string, (context: any, condition: any) => boolean>;
+    /** Custom action handlers */
+    actions?: Record<string, (config: any, context: any) => any>;
+    /** Custom response transforms */
+    transforms?: Record<string, (data: any, config: any) => any>;
+    /** Custom resolver functions */
+    resolvers?: Record<string, (params: any) => Promise<any>>;
+    /** Custom formatters (for table cells, display values) */
+    formatters?: Record<string, (value: any, options?: any) => string>;
+    /** Custom pipes */
+    pipes?: Record<string, (value: any, ...args: any[]) => any>;
+    /** API interceptors */
+    interceptors?: {
+        request?: (config: any) => any;
+        response?: (response: any) => any;
+        error?: (error: any) => any;
+    };
+    /** Action middleware — runs before every action dispatch */
+    actionMiddleware?: (action: ActionMeta, context: any) => ActionMeta | null;
+    /** Called when plugin is registered */
+    initialize?: () => void;
+    /** Called when plugin is destroyed */
+    destroy?: () => void;
+    /** Called after all plugins are registered */
+    afterInit?: () => void;
+    /** Catch-all */
+    [key: string]: any;
+}
+
+/**
+ * AvoraMetaForge — Page Metadata
+ *
+ * Comprehensive page configuration supporting:
+ * - Lifecycle hooks: onInit, onDestroy, onParamChange, onQueryChange
+ * - Breadcrumbs with dynamic segments
+ * - Deactivation guards (unsaved changes warning)
+ * - SEO meta tags
+ * - Page-level animations and transitions
+ * - Deep link support with route param context
+ */
+
+interface PageMeta {
+    id: string;
+    path: string;
+    title?: string;
+    layout?: LayoutTypeKey | string;
+    layoutConfig?: LayoutConfigMeta;
+    icon?: string;
+    guard?: GuardMeta;
+    resolve?: Record<string, ResolverMeta>;
+    sections: SectionMeta[];
+    data?: Record<string, any>;
+    children?: PageMeta[];
+    lazyModule?: () => Promise<any>;
+    showInNav?: boolean;
+    navGroup?: string;
+    navBadge?: string;
+    navBadgeColor?: string;
+    navOrder?: number;
+    pathMatch?: 'full' | 'prefix';
+    redirectTo?: string;
+    cssClass?: string;
+    customComponent?: () => Promise<any>;
+    /** Action to dispatch when the page initializes (e.g., load data) */
+    onInit?: ActionMeta;
+    /** Action to dispatch when the page is destroyed (e.g., cleanup) */
+    onDestroy?: ActionMeta;
+    /** Action to dispatch when route params change (for reusable pages) */
+    onParamChange?: ActionMeta;
+    /** Action to dispatch when query params change */
+    onQueryChange?: ActionMeta;
+    /** Action to dispatch when the page becomes visible (tab focus) */
+    onActivate?: ActionMeta;
+    /** Action to dispatch when the page loses visibility (tab blur) */
+    onDeactivate?: ActionMeta;
+    /** Whether to warn when leaving with unsaved changes */
+    canDeactivate?: boolean;
+    /** Custom deactivation message */
+    deactivateMessage?: string;
+    /** Condition that must be true to allow deactivation without prompt */
+    deactivateWhen?: ConditionMeta;
+    /** Breadcrumb configuration. Auto-generated from route hierarchy if not specified */
+    breadcrumbs?: BreadcrumbMeta[];
+    /** Override parent breadcrumbs (don't inherit) */
+    breadcrumbOverride?: boolean;
+    /** Hide breadcrumbs on this page */
+    hideBreadcrumbs?: boolean;
+    /** Meta description for search engines */
+    metaDescription?: string;
+    /** Meta keywords */
+    metaKeywords?: string[];
+    /** Open Graph meta tags */
+    og?: {
+        title?: string;
+        description?: string;
+        image?: string;
+        type?: string;
+    };
+    /** Page transition animation */
+    animation?: 'fade' | 'slide-left' | 'slide-right' | 'slide-up' | 'zoom' | 'none' | string;
+    /** Auto-refresh page data at this interval (ms) */
+    refreshInterval?: number;
+    /** Show loading skeleton while resolving data */
+    showSkeleton?: boolean;
+    /** Scroll to top on navigation */
+    scrollToTop?: boolean;
+    /** Page-level permissions (finer than guard) */
+    permissions?: string[];
+    /** Whether this page is a full-screen overlay */
+    fullScreen?: boolean;
+    /** Background color/gradient override */
+    background?: string;
+    /** Catch-all for future / plugin-specific properties */
+    [key: string]: any;
+}
+interface BreadcrumbMeta {
+    /** Display label. Supports template: '{{params.name}}' */
+    label: string;
+    /** Route path. If omitted, breadcrumb is not clickable */
+    path?: string;
+    /** Icon for the breadcrumb */
+    icon?: string;
+    /** Whether this is the active/current breadcrumb */
+    active?: boolean;
+    /** Action to dispatch on click (alternative to path) */
+    action?: ActionMeta;
+}
+
+type LayoutTypeKey = 'vertical' | 'horizontal' | 'empty' | 'centered' | 'two-column' | 'dashboard-grid' | 'compact' | 'sidebar-left' | 'sidebar-right' | 'split' | 'stacked' | 'masonry' | 'holy-grail';
+interface AppMeta {
+    app: AppBrandingMeta;
+    navigation: NavGroupMeta[];
+    pages: PageMeta[];
+    apis?: ApiEndpointMeta[];
+    /** Environment-based base URL mapping */
+    environments?: Record<string, EnvironmentConfig>;
+    /** Current active environment */
+    activeEnvironment?: string;
+    /** Global default headers for all API calls */
+    defaultHeaders?: Record<string, string>;
+    /** Global auth configuration */
+    auth?: GlobalAuthMeta;
+    /** Enable devtools overlay */
+    devtools?: boolean;
+    /** Global loading indicator configuration */
+    loading?: {
+        type?: 'spinner' | 'bar' | 'skeleton';
+        color?: string;
+        delay?: number;
+    };
+    /** Global error handler action */
+    onError?: ActionMeta;
+    /** Plugin configurations */
+    plugins?: AvoraMetaForgePlugin[];
+    /** Catch-all */
+    [key: string]: any;
+}
+interface EnvironmentConfig {
+    /** Base URL for API calls */
+    baseUrl: string;
+    /** Debug mode */
+    debug?: boolean;
+    /** Force mock mode for all endpoints */
+    mockAll?: boolean;
+    /** Additional config */
+    [key: string]: any;
+}
+interface GlobalAuthMeta {
+    /** Auth provider type */
+    type: 'jwt' | 'oauth2' | 'session' | 'apiKey' | 'custom';
+    /** Login endpoint ID */
+    loginEndpoint?: string;
+    /** Token refresh endpoint ID */
+    refreshEndpoint?: string;
+    /** Logout endpoint ID */
+    logoutEndpoint?: string;
+    /** Token storage location */
+    tokenStorage?: 'localStorage' | 'sessionStorage' | 'memory';
+    /** Token key in storage */
+    tokenKey?: string;
+    /** Refresh token key in storage */
+    refreshTokenKey?: string;
+    /** Auto-refresh token before expiry */
+    autoRefresh?: boolean;
+    /** Login redirect path */
+    loginRedirect?: string;
+    /** After-login default path */
+    afterLoginRedirect?: string;
+    /** Header name for token (default: 'Authorization') */
+    headerName?: string;
+    /** Token prefix (default: 'Bearer ') */
+    tokenPrefix?: string;
+    /**
+     * AvoraMetaForge Built-in Native Auth UI
+     * Let the framework handle auth screens for you using the AmfAuthShell.
+     */
+    builtInUI?: {
+        enabled: boolean;
+        /** Specific pages to enable. If omitted, all defaults are enabled. */
+        pages?: ('login' | 'forgot-password' | 'contact-support')[];
+        /** Custom brand name for auth pages. Fallbacks to app.name */
+        brandName?: string;
+        /** Custom tagline for auth pages */
+        brandTagline?: string;
+    };
+}
+interface AppBrandingMeta {
+    name: string;
+    logo?: string;
+    /** Logo for dark mode */
+    logoDark?: string;
+    /** Favicon URL */
+    favicon?: string;
+    defaultLayout?: LayoutTypeKey | string;
+    defaultGuard?: GuardMeta;
+    copyright?: string;
+    footerLinks?: FooterLinkMeta[];
+    /** Theme configuration */
+    theme?: ThemeMeta;
+    /** App version */
+    version?: string;
+    /** Support URL or email */
+    support?: string;
+    [key: string]: any;
+}
+interface ThemeMeta {
+    /** Primary color (hex or HSL) */
+    primary?: string;
+    /** Accent color */
+    accent?: string;
+    /** Default mode */
+    mode?: 'light' | 'dark' | 'auto';
+    /** Custom CSS variables */
+    variables?: Record<string, string>;
+    /** Font family */
+    fontFamily?: string;
+    /** Border radius scale */
+    borderRadius?: string;
+}
+interface LayoutMeta {
+    type: LayoutTypeKey | string;
+    config?: LayoutConfigMeta;
+}
+interface LayoutConfigMeta {
+    maxWidth?: string;
+    verticalCenter?: boolean;
+    leftWidth?: string;
+    rightWidth?: string;
+    collapsible?: boolean;
+    gridColumns?: number;
+    gridGap?: string;
+    hideHeader?: boolean;
+    hideFooter?: boolean;
+    headerHeight?: string;
+    showBreadcrumbs?: boolean;
+    showPageTitle?: boolean;
+    customCssClass?: string;
+    /** Sidebar config */
+    sidebar?: {
+        width?: string;
+        collapsible?: boolean;
+        defaultCollapsed?: boolean;
+        breakpoint?: number;
+    };
+    /** Padding */
+    padding?: string;
+    [key: string]: any;
+}
+interface NavGroupMeta {
+    label: string;
+    items: NavItemMeta[];
+    visibleWhen?: ConditionMeta;
+    /** Collapsed by default */
+    collapsed?: boolean;
+    /** Group icon */
+    icon?: string;
+}
+interface NavItemMeta {
+    label: string;
+    icon?: string;
+    route?: string;
+    children?: NavItemMeta[];
+    badge?: string;
+    badgeColor?: string;
+    visibleWhen?: ConditionMeta;
+    roles?: string[];
+    permissions?: string[];
+    action?: ActionMeta;
+    /** Open in new tab */
+    external?: boolean;
+    /** External URL */
+    url?: string;
+    /** Tooltip */
+    tooltip?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Divider after this item */
+    divider?: boolean;
+    [key: string]: any;
+}
+interface FooterLinkMeta {
+    label: string;
+    url?: string;
+    route?: string;
+    external?: boolean;
+    icon?: string;
+}
+
+interface DialogConfig {
+    title?: string;
+    message: string;
+    icon?: string;
+    variant?: 'info' | 'success' | 'warning' | 'danger';
+    confirmLabel?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+}
+
+type CustomActionFn = (config: any, context: any) => any;
+declare class ActionDispatcherService {
+    private readonly router;
+    private readonly titleService;
+    private readonly notifications;
+    private readonly apiService;
+    private readonly stateService;
+    private readonly conditionEvaluator;
+    private readonly dialogService;
+    private readonly customHandlers;
+    private readonly _events$;
+    private readonly _modalEvents$;
+    private readonly _drawerEvents$;
+    private readonly _formEvents$;
+    private readonly _tableEvents$;
+    private readonly _loadingState;
+    /** General event bus */
+    readonly events$: rxjs.Observable<{
+        event: string;
+        payload: any;
+    }>;
+    /** Modal open/close events */
+    readonly modalEvents$: rxjs.Observable<{
+        action: "open" | "close";
+        config: any;
+    }>;
+    /** Drawer open/close events */
+    readonly drawerEvents$: rxjs.Observable<{
+        action: "open" | "close";
+        config: any;
+    }>;
+    /** Form manipulation events */
+    readonly formEvents$: rxjs.Observable<{
+        action: "reset" | "patch" | "submit";
+        config: any;
+    }>;
+    /** Table reload events */
+    readonly tableEvents$: rxjs.Observable<{
+        action: "reload";
+        config: any;
+    }>;
+    /** Register a custom action handler */
+    registerHandler(type: string, handler: CustomActionFn): void;
+    /** Check loading state */
+    isLoading(key?: string): boolean;
+    dispatch(action: ActionMeta, context?: any): Promise<any>;
+    private handleNavigate;
+    private handleApi;
+    private handleNotify;
+    /** Replace {{key}} and {{key.nested}} tokens with values from context */
+    private interpolateTemplate;
+    private handleEmit;
+    private handleConfirm;
+    private handleSetState;
+    private handleClearState;
+    private handleScrollTo;
+    private handleFocus;
+    private handleBlur;
+    private handleToggleClass;
+    private handleSetLoading;
+    private handleDownloadFile;
+    private handleCopyToClipboard;
+    private handleOpenUrl;
+    private handleSetStorage;
+    private handleRemoveStorage;
+    private handleDispatchMultiple;
+    private handleDelay;
+    private handleConditional;
+    private handleForEach;
+    private handleTransformContext;
+    private handleLog;
+    private handlePrint;
+    /**
+     * Built-in CLIENT-SIDE CRUD SIMULATOR — for demos and testbeds only.
+     *
+     * This action uses `sessionStorage` as a temporary in-memory database so that
+     * CRUD operations (add / edit / delete) work without any backend connection.
+     * Data does NOT persist across browser sessions or tabs.
+     *
+     * ## When to use this
+     * Use `store-data` when you want to demonstrate or test a complete CRUD flow
+     * (Add → Edit → Delete) entirely in the browser, with zero backend setup.
+     * It is intentionally available to any AvoraMetaForge user for rapid prototyping.
+     *
+     * ## How to switch to a real backend
+     * Replace the `store-data` action with an `api` action pointing to your endpoint:
+     *
+     * ```ts
+     * // BEFORE (client-side mock):
+     * { type: 'store-data', config: { storageKey: 'amf_table_users', action: 'add' } }
+     *
+     * // AFTER (real backend):
+     * { type: 'api', config: { endpointId: 'create-user', body: 'formValue',
+     *                           storeResultAs: 'newUser' } }
+     * ```
+     *
+     * ## Config options
+     * - `storageKey`        — sessionStorage key (default: 'amf_demo_data')
+     * - `action`            — 'add' | 'edit' | 'delete'
+     * - `identifierKey`     — row identity field (default: 'id')
+     * - `computedFields`    — derived string fields interpolated from formValue
+     * - `autoTimestampField`— if set, auto-stamps this field with an ISO date on 'add'
+     */
+    private handleStoreData;
+    private resolveContextPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionDispatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionDispatcherService>;
+}
+
+type CustomEvaluatorFn = (context: any, condition: ConditionMeta) => boolean;
+declare class ConditionEvaluatorService {
+    private customEvaluators;
+    /** Register a custom evaluator function (from plugins or app code) */
+    registerEvaluator(key: string, fn: CustomEvaluatorFn): void;
+    /** Evaluate a condition against a context object */
+    evaluate(condition: ConditionMeta | undefined, context: Record<string, any>): boolean;
+    private resolveFieldValue;
+    private compare;
+    private getLength;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionEvaluatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConditionEvaluatorService>;
+}
+
+/**
+ * AvoraMetaForge — Component Registry Service
+ */
+
+declare class ComponentRegistryService {
+    private readonly registry;
+    register(key: string, component: Type<any>): void;
+    registerAll(entries: Record<string, Type<any>>): void;
+    get(key: string): Type<any> | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    unregister(key: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+declare class MetaRouterService {
+    private readonly router;
+    /**
+     * Called during APP_INITIALIZER to register all metadata-driven routes.
+     * Preserves any existing static routes (e.g. login) already registered
+     * via app.routes.ts, then appends dynamically generated routes.
+     */
+    registerApp(appMeta: AppMeta): void;
+    /**
+     * Recursively converts PageMeta[] into Angular Route[].
+     */
+    private buildPageRoutes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaRouterService>;
+}
+
+/**
+ * AvoraMetaForge — Meta Section Interface
+ */
+
+declare const META_SECTION_CONFIG: InjectionToken<any>;
+declare const META_SECTION_CONTEXT: InjectionToken<any>;
+interface MetaSectionComponent<T = any> {
+    config: T;
+    context?: any;
+}
+
+declare class MetaPageComponent implements OnDestroy {
+    private readonly route;
+    private readonly router;
+    private readonly titleService;
+    private readonly actionDispatcher;
+    private readonly dialogService;
+    private readonly destroyRef;
+    private subscriptions;
+    private previousParams;
+    private previousQueryParams;
+    private initDispatched;
+    /** Reactive route data — updates automatically on navigation */
+    private readonly routeData;
+    /** Computed PageMeta from route data */
+    readonly pageMeta: i0.Signal<PageMeta>;
+    /** Computed context from route data */
+    readonly context: i0.Signal<{
+        params: Params;
+        queryParams: Params;
+        state: any;
+        data: Data;
+        pageMeta: PageMeta;
+    }>;
+    constructor();
+    private onPageMetaChange;
+    ngOnDestroy(): void;
+    /**
+     * canDeactivate check — called by the router guard.
+     * Returns true if safe to navigate away, or a confirm dialog if dirty.
+     */
+    canDeactivate(): boolean | Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaPageComponent, "amf-page", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * CanActivate guard — controls whether a page can be accessed
+ */
+declare const metaGuard: CanActivateFn;
+/**
+ * CanDeactivate guard — warns before leaving if page has unsaved changes
+ */
+declare const metaCanDeactivateGuard: CanDeactivateFn<MetaPageComponent>;
+
+/**
+ * Returns the routing configuration for AvoraMetaForge's built-in auth UI.
+ * Connect this output to your main `app.routes.ts`.
+ */
+declare function getAmfAuthRoutes(meta: AppMeta): Routes;
+
+/**
+ * AvoraMetaForge — Meta Renderer Component
+ */
+
+declare class MetaRendererComponent implements OnChanges, OnDestroy {
+    section: SectionMeta;
+    context: any;
+    outlet: ViewContainerRef;
+    private readonly registry;
+    private readonly conditionEvaluator;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private render;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaRendererComponent, "amf-renderer", never, { "section": { "alias": "section"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AccordionSectionComponent implements MetaSectionComponent<AccordionMeta>, OnChanges {
+    config: AccordionMeta;
+    context: any;
+    private readonly conditionEvaluator;
+    /** Set of open panel indices */
+    openPanels: i0.WritableSignal<Set<number>>;
+    ngOnChanges(changes: SimpleChanges): void;
+    visiblePanels(): AccordionPanelMeta[];
+    isOpen(index: number): boolean;
+    togglePanel(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionSectionComponent, "amf-accordion-section", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MetaModalHostComponent implements OnInit, OnDestroy {
+    private dispatcher;
+    private sub?;
+    isOpen: i0.WritableSignal<boolean>;
+    config: i0.WritableSignal<any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    closeOnBackdrop(e: Event): void;
+    dispatchAction(actionMeta: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaModalHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaModalHostComponent, "amf-modal-host", never, {}, {}, never, never, true, never>;
+}
+
+interface DialogRequest {
+    config: DialogConfig;
+    resolve: (value: boolean) => void;
+}
+
+/**
+ * A simple SVG icon registry so the template doesn't depend on external icon fonts.
+ * Icons are registered as inline SVG path data keyed by name.
+ */
+declare class IconRegistryService {
+    private icons;
+    constructor();
+    /** Register a named SVG icon (viewBox 0 0 24 24) */
+    register(name: string, svgPath: string): void;
+    /** Get SVG path data for a named icon */
+    getIcon(name: string): string;
+    /** Check if an icon exists */
+    has(name: string): boolean;
+    private registerDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconRegistryService>;
+}
+
+declare class AmfDialogHostComponent implements OnInit, OnDestroy {
+    readonly iconRegistry: IconRegistryService;
+    private readonly dialogService;
+    private sub?;
+    currentDialog: i0.WritableSignal<DialogRequest | null>;
+    get iconPath(): string | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onBackdropClick(): void;
+    close(result: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AmfDialogHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AmfDialogHostComponent, "amf-dialog-host", never, {}, {}, never, never, true, never>;
+}
+
+declare class AmfDrawerHostComponent implements OnInit, OnDestroy {
+    private readonly dispatcher;
+    private sub?;
+    isOpen: i0.WritableSignal<boolean>;
+    config: i0.WritableSignal<any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    closeOnBackdrop(): void;
+    dispatchAction(actionMeta: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AmfDrawerHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AmfDrawerHostComponent, "amf-drawer-host", never, {}, {}, never, never, true, never>;
+}
+
+declare class MetaApiService {
+    private readonly http;
+    private readonly state;
+    private endpoints;
+    private cache;
+    private environments;
+    private activeEnvironment;
+    private globalHeaders;
+    private customTransforms;
+    registerEndpoints(apis: ApiEndpointMeta[]): void;
+    registerEnvironments(envs: Record<string, {
+        baseUrl: string;
+        [key: string]: any;
+    }>, active?: string): void;
+    setActiveEnvironment(env: string): void;
+    setGlobalHeaders(headers: Record<string, string>): void;
+    registerTransform(key: string, fn: (data: any, config: any) => any): void;
+    getEndpoint(id: string): ApiEndpointMeta | undefined;
+    call(id: string, dynamicParams?: Record<string, string>, dynamicBody?: any, options?: {
+        headers?: Record<string, string>;
+        queryParams?: Record<string, string>;
+        paginationParams?: Record<string, string>;
+    }): Promise<any>;
+    /**
+     * Direct call without registered endpoint — supports inline config
+     */
+    callDirect(config: {
+        url: string;
+        method: HttpMethod;
+        body?: any;
+        headers?: Record<string, string>;
+        queryParams?: Record<string, string>;
+        responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+        timeout?: number;
+    }): Promise<any>;
+    /** Invalidate cache for a specific endpoint */
+    invalidateCache(endpointId: string): void;
+    /** Invalidate all caches */
+    invalidateAllCache(): void;
+    /** Invalidate caches linked via invalidateOn */
+    invalidateLinkedCaches(triggeredEndpointId: string): void;
+    private injectAuth;
+    private handleMock;
+    private applyTransform;
+    private pickKeys;
+    private omitKeys;
+    private getCacheKey;
+    private getCached;
+    private storeInCache;
+    private retryWithBackoff;
+    private resolveBaseUrl;
+    private toFormData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaApiService>;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+
+interface StateChange {
+    key: string;
+    previousValue: any;
+    newValue: any;
+    timestamp: number;
+}
+declare class MetaStateService {
+    /** Internal state map — each key holds a signal */
+    private readonly store;
+    private readonly persistedKeys;
+    private readonly _changes$;
+    /** Observable stream of all state changes */
+    readonly changes$: rxjs.Observable<StateChange>;
+    /** Set a value in the store */
+    set(key: string, value: any, persist?: boolean): void;
+    /** Get current value of a key */
+    get(key: string): any;
+    /** Get a signal for reactive binding */
+    select(key: string): Signal<any>;
+    /** Computed signal derived from one or more keys */
+    selectComputed(keys: string[], fn: (...values: any[]) => any): Signal<any>;
+    /** Merge value with existing (for objects) */
+    merge(key: string, partial: Record<string, any>, persist?: boolean): void;
+    /** Patch a nested path within a stored object */
+    patch(key: string, path: string, value: any, persist?: boolean): void;
+    /** Check if a key exists */
+    has(key: string): boolean;
+    /** Remove a key from the store */
+    clear(key: string, clearPersisted?: boolean): void;
+    /** Reset entire store */
+    resetAll(clearPersisted?: boolean): void;
+    /** Reset specific namespace (e.g., clear all 'page.users.*' keys) */
+    clearNamespace(namespace: string, clearPersisted?: boolean): void;
+    /** Get all keys under a namespace as an object */
+    getNamespace(namespace: string): Record<string, any>;
+    /** Set multiple keys at once */
+    setMany(entries: Record<string, any>, persist?: boolean): void;
+    /** Get all keys and values as a plain object */
+    snapshot(): Record<string, any>;
+    /** Resolve a value that might be prefixed with 'state:' */
+    resolveValue(value: any): any;
+    private getOrCreateSignal;
+    private storageKey;
+    private persistToStorage;
+    private loadFromStorage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaStateService>;
+}
+
+interface AuthUser {
+    id?: string;
+    email?: string;
+    name?: string;
+    roles?: string[];
+    permissions?: string[];
+    avatar?: string;
+    [key: string]: any;
+}
+declare class MetaAuthService {
+    private readonly state;
+    private readonly apiService;
+    private config;
+    private refreshTimer;
+    /** Initialize auth from AppMeta config */
+    configure(authConfig: GlobalAuthMeta): void;
+    /** Store auth token and update state */
+    setToken(token: string, refreshToken?: string): void;
+    /** Get current token */
+    getToken(): string | null;
+    /** Get current refresh token */
+    getRefreshToken(): string | null;
+    /** Check if user is authenticated */
+    isAuthenticated(): boolean;
+    /** Set the current user */
+    setUser(user: AuthUser): void;
+    /** Get current user */
+    getUser(): AuthUser | null;
+    /** Check if user has a specific role */
+    hasRole(role: string): boolean;
+    /** Check if user has ANY of the specified roles */
+    hasAnyRole(roles: string[]): boolean;
+    /** Check if user has a specific permission */
+    hasPermission(permission: string): boolean;
+    /** Check if user has ALL specified permissions */
+    hasAllPermissions(permissions: string[]): boolean;
+    /** Perform login via configured endpoint */
+    login(credentials: Record<string, any>): Promise<any>;
+    /** Perform logout */
+    logout(): Promise<void>;
+    /** Refresh the auth token */
+    refreshAuthToken(): Promise<string | null>;
+    private scheduleTokenRefresh;
+    private getStorage;
+    private getStoredToken;
+    private getFromStorage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaAuthService>;
+}
+
+declare class PluginRegistryService {
+    private plugins;
+    register(plugin: AvoraMetaForgePlugin): void;
+    getAll(): AvoraMetaForgePlugin[];
+    get(name: string): AvoraMetaForgePlugin | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PluginRegistryService>;
+}
+
+/**
+ * AvoraMetaForge — Form Renderer Component
+ */
+
+declare class FormRendererComponent implements MetaSectionComponent<FormMeta>, OnInit, OnChanges, OnDestroy {
+    config: FormMeta;
+    context: any;
+    formSubmit: EventEmitter<any>;
+    formCancel: EventEmitter<void>;
+    formChange: EventEmitter<any>;
+    formGroup: FormGroup;
+    private readonly validatorFactory;
+    private readonly conditionEvaluator;
+    readonly actionDispatcher: ActionDispatcherService;
+    private readonly stateService;
+    private sub?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    get visibleFields(): FieldMeta[];
+    /** Normalize fields: ensure every field has a `key` (falling back to `name` for backward compat) */
+    private get normalizedFields();
+    get layoutClass(): string;
+    get gridColumns(): string | null;
+    onSubmit(): void;
+    handleCancel(): void;
+    private buildForm;
+    buildControls(fields: FieldMeta[], rowData: any, statePrefix: string): Record<string, AbstractControl>;
+    private markAllTouched;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormRendererComponent, "amf-form-renderer", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "formSubmit": "formSubmit"; "formCancel": "formCancel"; "formChange": "formChange"; }, never, never, true, never>;
+}
+
+declare class StepperFormRendererComponent implements MetaSectionComponent<FormMeta>, OnInit, OnChanges, OnDestroy {
+    config: FormMeta;
+    context: any;
+    formSubmit: EventEmitter<any>;
+    formCancel: EventEmitter<void>;
+    formGroup: FormGroup;
+    private readonly validatorFactory;
+    private readonly conditionEvaluator;
+    readonly actionDispatcher: ActionDispatcherService;
+    private readonly stateService;
+    private sub?;
+    currentStep: i0.WritableSignal<number>;
+    completedSteps: i0.WritableSignal<Set<number>>;
+    skippedSteps: i0.WritableSignal<Set<number>>;
+    stepErrors: i0.WritableSignal<string[]>;
+    resolvedSteps: i0.Signal<FormStepMeta[]>;
+    progressPercent: i0.Signal<number>;
+    currentGridColumns: i0.Signal<string>;
+    ngOnInit(): void;
+    resetForm(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    currentStepVisibleFields: i0.Signal<FieldMeta[]>;
+    private get normalizedFields();
+    isCompleted(index: number): boolean;
+    isSkipped(index: number): boolean;
+    canNavigateTo(index: number): boolean;
+    goToStep(index: number): void;
+    goNext(): void;
+    goBack(): void;
+    skipStep(): void;
+    onSubmit(): void;
+    private buildForm;
+    private buildControls;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperFormRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperFormRendererComponent, "amf-stepper-form-renderer", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "formSubmit": "formSubmit"; "formCancel": "formCancel"; }, never, never, true, never>;
+}
+
+declare class RepeaterFieldComponent {
+    field: FieldMeta;
+    formArray: FormArray;
+    formDisabled: boolean;
+    actionDispatcher: any;
+    context: any;
+    private readonly validatorFactory;
+    get canAdd(): boolean;
+    get canRemove(): boolean;
+    getFormGroup(ctrl: any): FormGroup;
+    getGridStyle(field: FieldMeta): string;
+    addItem(): void;
+    removeItem(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeaterFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RepeaterFieldComponent, "amf-repeater-field", never, { "field": { "alias": "field"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "formDisabled": { "alias": "formDisabled"; "required": false; }; "actionDispatcher": { "alias": "actionDispatcher"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableRendererComponent implements MetaSectionComponent<TableMeta>, OnInit, OnDestroy {
+    config: TableMeta;
+    context: any;
+    rowAction: EventEmitter<{
+        actionId: string;
+        row: any;
+    }>;
+    readonly iconRegistry: IconRegistryService;
+    private readonly actionDispatcher;
+    private readonly apiService;
+    private readonly dialogService;
+    searchQuery: i0.WritableSignal<string>;
+    sortKey: i0.WritableSignal<string | null>;
+    sortDirection: i0.WritableSignal<"asc" | "desc">;
+    currentPage: i0.WritableSignal<number>;
+    exportMenuOpen: i0.WritableSignal<boolean>;
+    selectedRows: i0.WritableSignal<Set<any>>;
+    expandedRows: i0.WritableSignal<Set<any>>;
+    collapsedGroups: i0.WritableSignal<Set<string>>;
+    localColumns: i0.WritableSignal<ColumnMeta[]>;
+    editingCell: i0.WritableSignal<{
+        row: any;
+        key: string;
+    } | null>;
+    editBuffer: Record<string, any>;
+    editError: i0.WritableSignal<string | null>;
+    pageSizeOverride: i0.WritableSignal<number | null>;
+    private filterValues;
+    allData: i0.WritableSignal<any[]>;
+    private tableEventsSub?;
+    private sectionId?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadData;
+    private getStorageKey;
+    visibleColumns: i0.Signal<ColumnMeta[]>;
+    filteredData: i0.Signal<any[]>;
+    /** Flat list with injected group-header sentinel objects for @for rendering */
+    groupedRows: i0.Signal<any[]>;
+    activePageSize: i0.Signal<number>;
+    setPageSize(size: number | string): void;
+    paginatedData: i0.Signal<any[]>;
+    totalPages: i0.Signal<number>;
+    pageNumbers: i0.Signal<number[]>;
+    toggleSort(key: string): void;
+    getCellValue(row: any, key: string): any;
+    getFilterValue(key: string): string;
+    setFilterValue(key: string, value: string): void;
+    handleAction(action: TableActionMeta, row: any): Promise<void>;
+    handleRowClick(row: any): void;
+    toggleSelection(row: any): void;
+    toggleAllSelection(event: Event): void;
+    private emitSelectionChange;
+    isEditing(row: any, key: string): boolean;
+    startEdit(row: any, key: string, event: MouseEvent): void;
+    commitEdit(row: any, key: string): void;
+    /** Runs all validators for an inline-edit value. Returns the first error message, or null if valid. */
+    private runInlineValidators;
+    cancelEdit(): void;
+    toggleRowExpand(row: any): void;
+    toggleGroup(key: string): void;
+    getAggregate(colKey: string): {
+        label?: string;
+        value: string | number;
+    } | null;
+    exportData(format: string): void;
+    dropColumn(event: CdkDragDrop<string[]>): void;
+    dropRow(event: CdkDragDrop<any[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableRendererComponent, "amf-table-renderer", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "rowAction": "rowAction"; }, never, never, true, never>;
+}
+
+declare class CardSectionComponent implements MetaSectionComponent<CardMeta> {
+    config: CardMeta;
+    context: any;
+    readonly actionDispatcher: ActionDispatcherService;
+    private readonly sanitizer;
+    get trustedContent(): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardSectionComponent, "amf-card", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class StatsGridSectionComponent implements MetaSectionComponent<StatsGridMeta> {
+    config: StatsGridMeta;
+    context: any;
+    readonly iconRegistry: IconRegistryService;
+    get gridCols(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatsGridSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatsGridSectionComponent, "amf-stats-grid", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PageHeaderSectionComponent implements MetaSectionComponent<PageHeaderMeta> {
+    config: PageHeaderMeta;
+    context: any;
+    readonly actionDispatcher: ActionDispatcherService;
+    readonly iconRegistry: IconRegistryService;
+    get resolvedTitle(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageHeaderSectionComponent, "amf-page-header", never, { "config": { "alias": "config"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface NavItem {
+    label: string;
+    icon?: string;
+    route?: string;
+    children?: NavItem[];
+    badge?: string;
+    badgeColor?: string;
+}
+interface NavGroup {
+    label: string;
+    items: NavItem[];
+}
+declare class NavigationService {
+    private readonly metaConfig;
+    readonly menuItems: i0.WritableSignal<NavGroup[]>;
+    setMenuItems(groups: NavGroup[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+/**
+ * Defines the available layout types for the application shell.
+ * Used in route data to determine which layout wraps a given page.
+ */
+declare enum LayoutType {
+    /** Classic admin: sidebar left, header top */
+    VERTICAL = "vertical",
+    /** Modern admin: horizontal menu in header */
+    HORIZONTAL = "horizontal",
+    /** Blank wrapper for login, error, and standalone pages */
+    EMPTY = "empty",
+    /** Centered content card — wizards, onboarding, standalone forms */
+    CENTERED = "centered",
+    /** Split-pane master-detail — settings, detail views */
+    TWO_COLUMN = "two-column",
+    /** CSS Grid widget layout — analytics, monitoring dashboards */
+    DASHBOARD_GRID = "dashboard-grid",
+    /** Minimal chrome, auto-hiding header — data-dense, mobile-first */
+    COMPACT = "compact"
+}
+
+/**
+ * Central configuration service for the application shell.
+ * Manages layout state, branding, and global settings using Angular Signals.
+ */
+declare class AppConfigService implements OnDestroy {
+    private router;
+    /**
+     * Current active layout type.
+     * Initialized from the browser URL *before* Angular's first navigation so
+     * the correct layout shell renders on the very first frame, preventing the
+     * brief flash of the sidebar/navbar chrome on pages like /login.
+     */
+    private readonly _currentLayout;
+    /** Application display name */
+    readonly appName: i0.WritableSignal<string>;
+    /** Copyright text for the footer */
+    readonly copyrightText: i0.WritableSignal<string>;
+    /** Sidebar collapsed state */
+    readonly sidebarCollapsed: i0.WritableSignal<boolean>;
+    /** Public read-only accessor for the current layout */
+    readonly currentLayout: i0.Signal<LayoutType>;
+    private readonly stateService;
+    private readonly titleService;
+    private _settingsSub?;
+    /**
+     * Reads window.location.pathname before Angular's first navigation to
+     * determine the correct initial layout. Prevents the one-frame flash of
+     * the sidebar/navbar shell when refreshing on an auth-only page like /login.
+     */
+    private getInitialLayout;
+    constructor(router: Router);
+    ngOnDestroy(): void;
+    /** Update layout based on the current activated route data */
+    private updateLayoutFromUrl;
+    /** Set the layout type programmatically */
+    setLayout(type: LayoutType): void;
+    /** Toggle sidebar collapsed state */
+    toggleSidebar(): void;
+    /** Walk the route tree to find the deepest activated child */
+    private getDeepestRoute;
+    /** Apply settings persisted across sessions on startup */
+    private applyPersistedSettings;
+    /**
+     * Called whenever a settings.* state key changes (e.g. after the Settings
+     * form is submitted). Maps each key to the appropriate runtime effect.
+     */
+    private applySettingChange;
+    /**
+     * Toggles dark / light mode by setting data-color-scheme on <html>.
+     * Dark mode = no attribute (uses :root CSS vars from _variables.scss).
+     * Light mode = data-color-scheme="light" (overrides via _themes.scss).
+     */
+    private applyColorScheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConfigService>;
+}
+
+/**
+ * AvoraMetaForge — Provider Initialization
+ *
+ * Provides the APP_INITIALIZER factory that bootstraps the framework:
+ * 1. Registers built-in section components (form, table, card, etc.)
+ * 2. Registers API endpoint definitions
+ * 3. Registers environments and auth configuration
+ * 4. Generates and registers dynamic routes from metadata
+ * 5. Registers plugins (custom actions, validators, conditions, etc.)
+ * 6. Initializes MetaStateService and MetaAuthService
+ */
+
+declare const APP_META_CONFIG_TOKEN: InjectionToken<AppMeta>;
+
+/**
+ * Factory function invoked by APP_INITIALIZER before the app renders.
+ * Returns a synchronous function — Angular waits for it to complete
+ * before performing the initial navigation.
+ */
+declare function initializeAvoraMetaForge(registry: ComponentRegistryService, routerService: MetaRouterService, apiService: MetaApiService, stateService: MetaStateService, authService: MetaAuthService, actionDispatcher: ActionDispatcherService, conditionEvaluator: ConditionEvaluatorService, pluginRegistry: PluginRegistryService, navService: NavigationService, appConfigService: AppConfigService, config: AppMeta): () => void;
+/**
+ * Call this in app.config.ts to wire up AvoraMetaForge:
+ *
+ *   provideAvoraMetaForge(APP_META)
+ */
+declare function provideAvoraMetaForge(config: AppMeta): Provider[];
+
+interface UserProfile {
+    id: string;
+    name: string;
+    email: string;
+    avatar: string;
+    role: string;
+    company: string;
+}
+/**
+ * ╔══════════════════════════════════════════════════════════════════╗
+ * ║          DEMO / PROTOTYPE AUTH SERVICE — NOT FOR PRODUCTION      ║
+ * ╠══════════════════════════════════════════════════════════════════╣
+ * ║  This service simulates authentication entirely on the client.   ║
+ * ║  The login() method accepts ANY email and password and creates    ║
+ * ║  a fake JWT-shaped token. There is NO real credential check.      ║
+ * ║                                                                  ║
+ * ║  Purpose: let framework developers demo the full auth UI flow     ║
+ * ║  (login → guard → interceptor → logout) without a live backend.  ║
+ * ║                                                                  ║
+ * ║  ── TO SWITCH TO REAL AUTH ─────────────────────────────────── ║
+ * ║  Option A (recommended): Use MetaAuthService directly.           ║
+ * ║    • Configure `auth.loginEndpoint` in AppMeta to a real endpoint ║
+ * ║    • Remove mock:true from that endpoint definition              ║
+ * ║    • MetaAuthService handles token storage + auto-refresh        ║
+ * ║                                                                  ║
+ * ║  Option B: Keep this service but replace _mockLogin() body with  ║
+ * ║    a real HTTP call (e.g. via HttpClient or MetaApiService).     ║
+ * ║                                                                  ║
+ * ║  See FRAMEWORK_GUIDE.md §3 for a step-by-step migration guide.   ║
+ * ╚══════════════════════════════════════════════════════════════════╝
+ */
+declare class AuthService {
+    private router;
+    /**
+     * Sentinel flag — always `true` on this demo implementation.
+     * Production code can check `AuthService.IS_MOCK_AUTH` to detect
+     * whether real authentication is wired up.
+     */
+    static readonly IS_MOCK_AUTH = true;
+    private readonly TOKEN_KEY;
+    private readonly USER_KEY;
+    private readonly REDIRECT_KEY;
+    private readonly _user;
+    readonly user: i0.Signal<UserProfile | null>;
+    readonly isAuthenticated: i0.Signal<boolean>;
+    constructor(router: Router);
+    private getInitialUser;
+    /**
+     * Authenticate a user.
+     *
+     * ⚠️  DEMO IMPLEMENTATION — accepts any credentials.
+     * Internally delegates to `_mockLogin()` which fabricates a JWT-shaped
+     * token without contacting any server.
+     *
+     * To use real auth, replace the body of `_mockLogin()` (or this method)
+     * with an actual API call. See FRAMEWORK_GUIDE.md §3.
+     */
+    login(email: string, password: string): boolean;
+    /**
+     * ── MOCK IMPLEMENTATION ──────────────────────────────────────────
+     * Generates a fake JWT-shaped token and stores a fabricated user profile.
+     * This method has NO security — it accepts any email/password pair.
+     * It exists purely to allow testing the auth UI flow without a backend.
+     * ─────────────────────────────────────────────────────────────────
+     */
+    private _mockLogin;
+    /** Clear session and navigate to login */
+    logout(): void;
+    /** Get the raw token string */
+    getToken(): string | null;
+    /** Get the current user profile */
+    getUserProfile(): UserProfile | null;
+    /** Check if the current user has a specific role */
+    hasRole(role: string | string[]): boolean;
+    /** Store the URL the user was trying to access before being redirected to login */
+    storeRedirectUrl(url: string): void;
+    /** Check if the mock token is expired */
+    isTokenExpired(token?: string | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+/**
+ * Functional auth guard (CanActivateFn).
+ * - Checks if a valid (non-expired) token exists via AuthService.
+ * - Stores the attempted URL for post-login redirect.
+ * - Redirects unauthenticated users to /login.
+ *
+ * \u2500\u2500 CURRENT (DEMO) BEHAVIOUR \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Delegates to `AuthService` (the demo/mock auth service).
+ * The token it checks is a locally-generated fake JWT \u2014 no server
+ * validation occurs. The guard correctly protects routes in the demo
+ * but will let any fabricated token through.
+ *
+ * \u2500\u2500 PRODUCTION MIGRATION PATH \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+ * Option A \u2014 Use the framework\u2019s built-in MetaGuard:
+ *   Set `guard: { requireAuth: true, redirectTo: '/login' }` on any
+ *   PageMeta definition. MetaGuard already reads from MetaAuthService
+ *   and handles role/permission checks declaratively.
+ *
+ * Option B \u2014 Keep this guard but swap the auth service:
+ *   Replace `inject(AuthService)` with `inject(MetaAuthService)` and
+ *   call `.isAuthenticated()` on it once real tokens are in flight.
+ *
+ * See FRAMEWORK_GUIDE.md \u00a73 for step-by-step migration instructions.
+ */
+declare const authGuard: CanActivateFn;
+
+/**
+ * HTTP Interceptor — Bearer token injection + 401 global logout.
+ *
+ * ── CURRENT (DEMO) BEHAVIOUR ──────────────────────────────────────────────
+ * Reads the Bearer token from `AuthService` (the demo/mock service).
+ * The token is a fake JWT-shaped string generated locally — it will be
+ * rejected by any real API server that validates JWT signatures.
+ *
+ * ── PRODUCTION MIGRATION PATH ────────────────────────────────────────────
+ * Option A — Swap the token source (minimal change):
+ *   Replace `authService.getToken()` with a call to `MetaAuthService.getToken()`
+ *   once you have a real login endpoint producing real JWTs.
+ *
+ * Option B — Remove this interceptor entirely:
+ *   Use AvoraMetaForge’s built-in auth injection via `ApiEndpointMeta.auth`.
+ *   Set `auth: { type: 'bearer', token: 'state:auth.token' }` on each endpoint
+ *   and MetaApiService will inject it automatically. No interceptor needed.
+ *
+ * See FRAMEWORK_GUIDE.md §3 for step-by-step instructions.
+ */
+declare const authInterceptor: HttpInterceptorFn;
+
+/**
+ * Manages runtime theming by toggling the `data-theme` attribute on the <body> element.
+ * Allows switching brand skins without recompiling styles.
+ */
+declare class ThemeService {
+    /** Currently active theme name */
+    readonly currentTheme: i0.WritableSignal<string>;
+    /** Available theme names */
+    readonly availableThemes: ReadonlyArray<{
+        name: string;
+        label: string;
+    }>;
+    constructor();
+    /** Switch to a named theme */
+    setTheme(themeName: string): void;
+    /** Cycle to the next theme */
+    cycleTheme(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+type NotificationType = 'success' | 'error' | 'info' | 'warning';
+interface Notification {
+    id: number;
+    type: NotificationType;
+    message: string;
+    timeout?: number;
+}
+declare class NotificationService {
+    private _notifications;
+    readonly notifications: i0.Signal<Notification[]>;
+    private _counter;
+    /** Add a notification to the stack */
+    show(type: NotificationType, message: string, timeout?: number): void;
+    success(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+    warning(message: string): void;
+    /** Remove a notification by ID */
+    remove(id: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+/**
+ * The Root Renderer (Traffic Controller).
+ * Decides which layout to load based on the currentLayout signal from AppConfigService.
+ */
+declare class LayoutComponent {
+    readonly config: AppConfigService;
+    readonly LayoutType: typeof LayoutType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutComponent, "app-layout", never, {}, {}, never, never, true, never>;
+}
+
+export { APP_META_CONFIG_TOKEN, AccordionSectionComponent, ActionDispatcherService, AmfDialogHostComponent, AmfDrawerHostComponent, AppConfigService, AuthService, CardSectionComponent, ComponentRegistryService, ConditionEvaluatorService, FormRendererComponent, LayoutComponent, LayoutType, META_SECTION_CONFIG, META_SECTION_CONTEXT, MetaApiService, MetaAuthService, MetaModalHostComponent, MetaPageComponent, MetaRendererComponent, MetaRouterService, MetaStateService, NotificationService, PageHeaderSectionComponent, PluginRegistryService, RepeaterFieldComponent, StatsGridSectionComponent, StepperFormRendererComponent, TableRendererComponent, ThemeService, authGuard, authInterceptor, getAmfAuthRoutes, initializeAvoraMetaForge, metaCanDeactivateGuard, metaGuard, provideAvoraMetaForge };
+export type { AccordionMeta, AccordionPanelMeta, ActionMeta, ActionType, AggregateRowMeta, AlertMeta, ApiActionConfig, ApiAuthMeta, ApiEndpointMeta, ApiPaginationMeta, AppBrandingMeta, AppMeta, AuthUser, AutosaveMeta, AvoraMetaForgePlugin, BreadcrumbMeta, CacheMeta, CardMeta, CellType, ClearStateActionConfig, ColumnEditValidatorMeta, ColumnMeta, ComputeFieldMeta, ConditionMeta, ConditionOperator, ConditionalActionConfig, ConfirmActionConfig, CopyToClipboardActionConfig, CrossFieldValidatorMeta, CustomComponentMeta, DelayActionConfig, DialogConfig, DispatchMultipleActionConfig, DividerMeta, DownloadFileActionConfig, DrawerActionConfig, EmitActionConfig, EmptyStateMeta, EnvironmentConfig, FieldMeta, FieldType, FocusActionConfig, FooterLinkMeta, ForEachActionConfig, FormLayout, FormMeta, FormStepMeta, GlobalAuthMeta, GuardMeta, HtmlMeta, HttpMethod$1 as HttpMethod, IframeMeta, LayoutConfigMeta, LayoutMeta, LayoutTypeKey, LoadingActionConfig, LogActionConfig, MetaSectionComponent, ModalActionConfig, NavGroupMeta, NavItemMeta, NavigateActionConfig, Notification, NotificationType, NotifyActionConfig, OpenUrlActionConfig, OptionMeta, PageHeaderActionMeta, PageHeaderMeta, PageMeta, PaginationMeta, PatchFormActionConfig, PrintActionConfig, ReloadTableActionConfig, ResetFormActionConfig, ResolverMeta, RetryMeta, RowClassMeta, ScrollToActionConfig, SectionMeta, ServerPaginationConfig, SetStateActionConfig, SetTitleActionConfig, SpacerMeta, StatCardMeta, StateChange, StatsGridMeta, StorageActionConfig, SubmitFormActionConfig, TabMeta, TableActionMeta, TableFilterMeta, TableMeta, TabsMeta, ThemeMeta, TimelineItemMeta, TimelineMeta, ToggleClassActionConfig, TransformContextActionConfig, TransformMeta, UserProfile, ValidatorMeta };