@praxisui/core 1.0.0-beta.5 → 1.0.0-beta.52

package/index.d.ts

@@ -1,10 +1,11 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Provider, Type, EnvironmentProviders, OnInit, OnChanges, OnDestroy, EventEmitter, SimpleChanges, ElementRef, Renderer2 } from '@angular/core';
-import { HttpHeaders, HttpClient, HttpParams } from '@angular/common/http';
+import { InjectionToken, Type, Provider, ErrorHandler, EnvironmentProviders, OnInit, OnChanges, OnDestroy, EventEmitter, SimpleChanges, ElementRef, Renderer2 } from '@angular/core';
 import * as rxjs from 'rxjs';
 import { Observable, BehaviorSubject } from 'rxjs';
+import { HttpHeaders, HttpContext, HttpClient, HttpParams, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpContextToken } from '@angular/common/http';
 import { ValidationErrors, ValidatorFn, AsyncValidatorFn, FormControl, FormGroup } from '@angular/forms';
-import { ThemePalette } from '@angular/material/core';
+import { ThemePalette, DateAdapter } from '@angular/material/core';
+import { ActivatedRoute } from '@angular/router';
 import { MatDialogRef } from '@angular/material/dialog';
 
 declare class PraxisCore {
@@ -12,6 +13,219 @@ declare class PraxisCore {
     static ɵcmp: i0.ɵɵComponentDeclaration<PraxisCore, "praxis-praxis-core", never, {}, {}, never, never, true, never>;
 }
 
+interface HateoasLink {
+    href: string;
+    templated?: boolean;
+    type?: string;
+    deprecation?: string;
+    profile?: string;
+    name?: string;
+    title?: string;
+    hreflang?: string;
+    [prop: string]: any;
+}
+interface RestApiLinks {
+    [rel: string]: HateoasLink | HateoasLink[];
+}
+interface RestApiResponse<T> {
+    status?: string;
+    message?: string;
+    data: T;
+    _links?: RestApiLinks;
+    errors?: any;
+    timestamp?: string;
+}
+
+interface Page<T> {
+    content: T[];
+    totalElements: number;
+    totalPages: number;
+    size: number;
+    number: number;
+}
+interface CursorPage<T> {
+    content: T[];
+    next?: string | null;
+    prev?: string | null;
+    size: number;
+}
+
+interface OptionDTO<ID = string | number> {
+    id: ID;
+    label: string;
+    extra?: Record<string, unknown>;
+}
+
+interface PageableRequest {
+    pageNumber: number;
+    pageSize: number;
+    sort?: string[];
+}
+interface FilterOptions<ID = string | number> {
+    includeIds?: ID[];
+    observeVersionHeader?: boolean;
+}
+interface CursorRequest {
+    size?: number;
+    sort?: string[];
+    after?: string | null;
+    before?: string | null;
+}
+interface LocateRequest {
+    size: number;
+    sort?: string[];
+}
+
+/**
+ * Contrato de saída do normalizador de esquema (SchemaNormalizerService):
+ * - Converte metadados `x-ui` em FieldDefinition tipado.
+ * - Todas as funções expostas são funções reais (nunca strings):
+ *   - conditionalDisplay: () => boolean
+ *   - conditionalRequired: () => boolean
+ *   - transformValueFunction: (val: any) => any
+ * - Suporte completo a ValidatorOptions (sincronos e assíncronos),
+ *   incluindo mensagens e comportamento de validação (gatilhos, debounce, exibição de erros).
+ */
+interface FieldDefinition {
+    name: string;
+    label?: string;
+    description?: string;
+    type?: string;
+    controlType?: string;
+    mode?: string;
+    placeholder?: string;
+    defaultValue?: any;
+    group?: string;
+    order?: number;
+    width?: number | string;
+    isFlex?: boolean;
+    displayOrientation?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    multiple?: boolean;
+    editable?: boolean;
+    validationMode?: string;
+    unique?: boolean;
+    mask?: string;
+    sortable?: boolean;
+    /** Função que define obrigatoriedade condicional. */
+    conditionalRequired?: () => boolean;
+    viewOnlyStyle?: string;
+    /** Lista de gatilhos de validação, ex.: ["blur", "change"]. */
+    validationTriggers?: string[];
+    hidden?: boolean;
+    tableHidden?: boolean;
+    formHidden?: boolean;
+    filterable?: boolean;
+    /** Função que controla se o campo é exibido. */
+    conditionalDisplay?: () => boolean;
+    dependentField?: string;
+    resetOnDependentChange?: boolean;
+    inlineEditing?: boolean;
+    /** Função de transformação de valor antes de salvar/exibir. */
+    transformValueFunction?: (val: any) => any;
+    debounceTime?: number;
+    helpText?: string;
+    hint?: string;
+    hiddenCondition?: any;
+    tooltipOnHover?: boolean;
+    icon?: string;
+    iconPosition?: string;
+    iconSize?: string | number;
+    iconColor?: string;
+    iconClass?: string;
+    iconStyle?: string;
+    iconFontSize?: string | number;
+    valueField?: string;
+    displayField?: string;
+    endpoint?: string;
+    resourcePath?: string;
+    emptyOptionText?: string;
+    options?: {
+        key: string;
+        value: string;
+    }[];
+    filter?: any;
+    filterCriteria?: any;
+    searchable?: boolean;
+    selectAll?: boolean;
+    maxSelections?: number;
+    optionLabelKey?: string;
+    optionValueKey?: string;
+    filterOptions?: any[];
+    filterControlType?: string;
+    numericFormat?: string;
+    numericStep?: number;
+    numericMin?: number;
+    numericMax?: number;
+    numericMaxLength?: number;
+    optionGroups?: {
+        key: string;
+        value: string;
+    }[];
+    disabledOptions?: string[];
+    buttons?: any[];
+    /** Obrigatório. */
+    required?: boolean;
+    requiredMessage?: string;
+    /** Tamanho mínimo/máximo (strings). */
+    minLength?: number;
+    minLengthMessage?: string;
+    maxLength?: number;
+    maxLengthMessage?: string;
+    /** Limites numéricos. */
+    min?: number;
+    max?: number;
+    /** Mensagens dedicadas para min/max numéricos. */
+    minMessage?: string;
+    maxMessage?: string;
+    /** Mensagem quando ambos limites (range) são aplicados. */
+    rangeMessage?: string;
+    /** Padrão (regex). Aceita pattern/regex. */
+    pattern?: string;
+    patternMessage?: string;
+    /** Validação de e-mail. */
+    email?: boolean;
+    emailMessage?: string;
+    /** Validação de URL. */
+    url?: boolean;
+    urlMessage?: string;
+    /** Requer que valor combine com outro campo. */
+    matchField?: string;
+    matchFieldMessage?: string;
+    /** Requer que o checkbox esteja marcado. */
+    requiredChecked?: boolean;
+    /** Tipos de arquivo permitidos e tamanho máximo. */
+    allowedFileTypes?: string[];
+    fileTypeMessage?: string;
+    maxFileSize?: number;
+    /** Validador customizado síncrono. */
+    customValidator?: (value: any, model?: any) => any;
+    /** Validador customizado assíncrono. */
+    asyncValidator?: (value: any, model?: any) => Promise<any>;
+    /** Validador de unicidade (ex.: consulta ao backend). */
+    uniqueValidator?: (value: any, model?: any) => boolean | Promise<boolean>;
+    uniqueMessage?: string;
+    /** Validação condicional baseada em outro(s) campos/estado. */
+    conditionalValidation?: (value: any, model?: any) => boolean | string | Promise<boolean | string>;
+    /** Mínimo de palavras (para textos longos). */
+    minWords?: number;
+    /** Gatilho(s) de validação (alias de validationTriggers). */
+    /** Tempo de debounce (ms) para executar validação. */
+    validationDebounce?: number;
+    /** Exibir erros inline no campo. */
+    showInlineErrors?: boolean;
+    /** Posição preferida da mensagem de erro (ex.: below, right). */
+    errorPosition?: string;
+    [key: string]: any;
+}
+
+declare enum ApiEndpoint {
+    Default = "default",
+    HumanResources = "humanResources",
+    UiWrappersTest = "uiWrappersTest"
+}
+
 interface ApiUrlEntry {
     baseUrl?: string;
     path?: string;
@@ -27,17 +241,102 @@ declare function buildApiUrl(entry: ApiUrlEntry): string;
 declare function buildHeaders(entry: ApiUrlEntry): HttpHeaders | undefined;
 
 /**
- * Nova arquitetura modular do TableConfig v2.0
- * Preparada para crescimento exponencial e alinhada com as 5 abas do editor
+ * SchemaNormalizerService
+ * -----------------------
+ * Serviço responsável por converter um esquema bruto (OpenAPI + x-ui) em uma
+ * lista tipada de FieldDefinition consumida pelo restante do sistema
+ * (mapeadores de metadata, criador de FormGroup, carregador de campos dinâmicos, etc.).
+ *
+ * Entrada esperada
+ * - Objeto JSON no formato OpenAPI/JSON Schema contendo:
+ *   - properties: { [name: string]: { type, title, description, ... , 'x-ui': { ... } } }
+ *   - Em cada propriedade, o objeto 'x-ui' define aspectos de UI/validação.
+ *
+ * Saída (FieldDefinition[])
+ * - Tipagem forte de campos com funções reais (nunca strings) para regras condicionais e validadores customizados.
+ * - Todas as propriedades de validação e comportamento consolidadas no mesmo objeto do campo.
+ *
+ * Segurança e observações
+ * - Este serviço aceita funções em formato string dentro do x-ui (ex.: uniqueValidator, conditionalValidation),
+ *   e as converte via new Function. Isso exige backend confiável e controlado.
+ *   Em ambientes não confiáveis, evite funções como string ou implemente um sandbox/whitelist.
+ * - Valores booleanos/numéricos são normalizados para tipos nativos.
+ * - Arrays de opções são convertidos para pares { key, value } previsíveis.
+ *
+ * Exemplo mínimo de entrada
+ * const schema = {
+ *   properties: {
+ *     email: {
+ *       type: 'string',
+ *       title: 'E-mail',
+ *       'x-ui': { controlType: 'input', type: 'string', required: true, email: true }
+ *     }
+ *   }
+ * };
+ * const fields = normalizer.normalizeSchema(schema);
+ * // fields: [{ name: 'email', label: 'E-mail', type: 'string', controlType: 'input', required: true, email: true }]
  */
-interface ColumnDefinition {
-    /** Campo da fonte de dados */
-    field: string;
-    /** Cabeçalho da coluna */
-    header: string;
-    /** Tipo de dados para formatação */
-    type?: 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage' | 'custom';
-    /** Largura da coluna */
+declare class SchemaNormalizerService {
+    /** Convert value to boolean. Accepts boolean, string or number. */
+    private parseBoolean;
+    /** Ensure an array of strings from various inputs. */
+    private parseStringArray;
+    /** Parse option arrays into `{ key, value }` objects. */
+    private parseOptions;
+    /**
+     * Converte string/Function em função real.
+     * Atenção: usa `new Function` para avaliar strings – requer backend confiável.
+     */
+    private parseFunction;
+    /** Parse a predicate function: () => boolean */
+    private parsePredicateFunction;
+    /** Parse a transform function: (val: any) => any */
+    private parseTransformFunction;
+    /**
+     * Parse de validador condicional: (value: any, model?: any) => boolean | string | Promise<boolean | string>
+     */
+    private parseConditionalValidator;
+    /**
+     * Extrai e normaliza propriedades de validação a partir do objeto x-ui.
+     * Suporta: required, min/max, minLength/maxLength, pattern/regex, email, url,
+     * matchField, uniqueValidator (+message), conditionalValidation, requiredChecked,
+     * arquivos (allowedFileTypes, fileTypeMessage, maxFileSize), custom/async validators,
+     * minWords e comportamento (validationTrigger(s), validationDebounce, showInlineErrors, errorPosition).
+     */
+    private parseValidators;
+    /** Parse array of button definitions. */
+    private parseButtons;
+    private resolveNonEmptyStringToken;
+    private isNumericSchemaType;
+    private resolveNumericFormatToken;
+    /**
+     * Converte o schema bruto do backend (OpenAPI + x-ui) em FieldDefinition[] tipado.
+     * Regras:
+     * - Ignora propriedades sem x-ui.
+     * - Garante ordenação por 'order' quando presente.
+     * - Funções condicionais/transformações sempre viram funções reais.
+     *
+     * @param schema Objeto OpenAPI/JSON Schema com properties e x-ui por propriedade.
+     * @returns FieldDefinition[] prontos para mapeamento/uso no restante do sistema.
+     */
+    normalizeSchema(schema: any): FieldDefinition[];
+    private resolveFieldType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaNormalizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaNormalizerService>;
+}
+
+/**
+ * Nova arquitetura modular do TableConfig v2.0
+ * Preparada para crescimento exponencial e alinhada com as 5 abas do editor
+ */
+interface ColumnDefinition {
+    /** Campo da fonte de dados */
+    field: string;
+    /** Cabeçalho da coluna */
+    header: string;
+    /** Tipo de dados para formatação */
+    type?: 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage' | 'custom';
+    /** Largura da coluna */
     width?: string;
     /** Visibilidade da coluna */
     visible?: boolean;
@@ -65,12 +364,24 @@ interface ColumnDefinition {
     headerCssClass?: string;
     /** Formato de exibição dos dados */
     format?: any;
+    /** Coluna calculada baseada em expressão */
+    computed?: {
+        /** Expressão segura baseada em campos da linha */
+        expression: string;
+        /** Tipo do valor calculado para formatação */
+        outputType?: ColumnDefinition['type'];
+        /** Formato opcional do valor calculado */
+        format?: string;
+        /** Campos usados na expressão (opcional) */
+        dependencies?: string[];
+    };
     /** Mapeamento de valores para exibição */
     valueMapping?: {
         [key: string | number]: string;
     };
     /**
      * Renderizador de célula (Fase 1): opções básicas para ícone, imagem ou badge.
+     * Fase 2: expandido com tipos interativos/ricos (link, button, chip, progress, avatar, toggle, menu, html).
      * Mantém compatibilidade com type/format/valueMapping; quando definido, tem precedência na exibição.
      */
     renderer?: {
@@ -79,7 +390,7 @@ interface ColumnDefinition {
             expr: string;
         };
         /** Tipo do renderizador */
-        type: 'icon' | 'image' | 'badge';
+        type: 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'avatar' | 'toggle' | 'menu' | 'rating' | 'html' | 'compose';
         /** Configuração de ícone (Material/SVG por nome) */
         icon?: {
             /** Nome fixo do ícone (ex.: 'check_circle') */
@@ -126,7 +437,222 @@ interface ColumnDefinition {
             /** Ícone opcional dentro do badge */
             icon?: string;
         };
+        /** Link (sanitizado) */
+        link?: {
+            text?: string;
+            textField?: string;
+            href?: string;
+            hrefField?: string;
+            target?: '_blank' | '_self' | '_parent' | '_top';
+            rel?: string;
+        };
+        /** Botão (ação por linha) */
+        button?: {
+            label?: string;
+            labelField?: string;
+            icon?: string;
+            color?: 'primary' | 'accent' | 'warn' | string;
+            variant?: 'filled' | 'outlined' | 'text';
+            size?: 'sm' | 'md' | 'lg';
+            ariaLabel?: string;
+            disabledCondition?: string;
+            action?: {
+                id: string;
+                payloadExpr?: string;
+            };
+        };
+        /** Chip (etiqueta leve) */
+        chip?: {
+            text?: string;
+            textField?: string;
+            color?: string;
+            icon?: string;
+            variant?: 'filled' | 'outlined' | 'soft';
+        };
+        /** Barra de progresso leve */
+        progress?: {
+            valueExpr: string;
+            color?: string;
+            showLabel?: boolean;
+        };
+        /** Avaliação por estrelas (read-only em tabelas) */
+        rating?: {
+            valueExpr?: string;
+            max?: number;
+            color?: string;
+            outlineColor?: string;
+            size?: 'small' | 'medium' | 'large';
+            ariaLabel?: string;
+            readonly?: boolean;
+        };
+        /** Avatar (imagem ou iniciais) */
+        avatar?: {
+            src?: string;
+            srcField?: string;
+            alt?: string;
+            altField?: string;
+            initialsExpr?: string;
+            shape?: 'square' | 'rounded' | 'circle';
+            size?: number;
+        };
+        /** Alternância (toggle) com ação */
+        toggle?: {
+            stateExpr: string;
+            disabledCondition?: string;
+            action?: {
+                id: string;
+                payloadExpr?: string;
+            };
+            ariaLabel?: string;
+        };
+        /** Menu de ações
+         * itemsExpr → Array<{ label: string; icon?: string; id: string; payloadExpr?: string; visibleCondition?: string }> */
+        menu?: {
+            itemsExpr: string;
+            ariaLabel?: string;
+        };
+        /** HTML (sanitizado) com tokens [[field]] */
+        html?: {
+            template: string;
+            sanitize?: 'strict' | 'basic';
+            emptyFallback?: string;
+        };
+        /** Compose (multi-itens) */
+        compose?: {
+            items: Array<{
+                type: 'icon';
+                icon?: {
+                    name?: string;
+                    nameField?: string;
+                    color?: string;
+                    size?: number;
+                    ariaLabel?: string;
+                };
+            } | {
+                type: 'image';
+                image?: {
+                    src?: string;
+                    srcField?: string;
+                    alt?: string;
+                    altField?: string;
+                    width?: number;
+                    height?: number;
+                    shape?: 'square' | 'rounded' | 'circle';
+                    fit?: 'cover' | 'contain';
+                    lazy?: boolean;
+                };
+            } | {
+                type: 'badge';
+                badge?: {
+                    text?: string;
+                    textField?: string;
+                    color?: string;
+                    variant?: 'filled' | 'outlined' | 'soft';
+                    icon?: string;
+                };
+            } | {
+                type: 'link';
+                link?: {
+                    text?: string;
+                    textField?: string;
+                    href?: string;
+                    hrefField?: string;
+                    target?: '_blank' | '_self' | '_parent' | '_top';
+                    rel?: string;
+                };
+            } | {
+                type: 'button';
+                button?: {
+                    label?: string;
+                    labelField?: string;
+                    icon?: string;
+                    color?: string;
+                    variant?: 'filled' | 'outlined' | 'text';
+                    size?: 'sm' | 'md' | 'lg';
+                    disabledCondition?: string;
+                    action?: {
+                        id: string;
+                        payloadExpr?: string;
+                    };
+                };
+            } | {
+                type: 'chip';
+                chip?: {
+                    text?: string;
+                    textField?: string;
+                    color?: string;
+                    icon?: string;
+                    variant?: 'filled' | 'outlined' | 'soft';
+                };
+            } | {
+                type: 'progress';
+                progress?: {
+                    valueExpr: string;
+                    color?: string;
+                    showLabel?: boolean;
+                };
+            } | {
+                type: 'avatar';
+                avatar?: {
+                    src?: string;
+                    srcField?: string;
+                    alt?: string;
+                    altField?: string;
+                    initialsExpr?: string;
+                    shape?: 'square' | 'rounded' | 'circle';
+                    size?: number;
+                };
+            } | {
+                type: 'toggle';
+                toggle?: {
+                    stateExpr: string;
+                    disabledCondition?: string;
+                    action?: {
+                        id: string;
+                        payloadExpr?: string;
+                    };
+                };
+            } | {
+                type: 'menu';
+                menu?: {
+                    itemsExpr: string;
+                    ariaLabel?: string;
+                };
+            } | {
+                type: 'rating';
+                rating?: {
+                    valueExpr?: string;
+                    max?: number;
+                    color?: string;
+                    outlineColor?: string;
+                    size?: 'small' | 'medium' | 'large';
+                    ariaLabel?: string;
+                    readonly?: boolean;
+                };
+            } | {
+                type: 'html';
+                html?: {
+                    template: string;
+                    sanitize?: 'strict' | 'basic';
+                    emptyFallback?: string;
+                };
+            }>;
+            layout?: {
+                direction?: 'row' | 'column';
+                gap?: number;
+                align?: 'start' | 'center' | 'end';
+                wrap?: boolean;
+                ellipsis?: boolean;
+            };
+        };
     };
+    /** Overrides condicionais do renderer por linha (first‑match wins) */
+    conditionalRenderers?: Array<{
+        condition: string;
+        renderer: Partial<ColumnDefinition['renderer']>;
+        description?: string;
+        enabled?: boolean;
+    }>;
     /**
      * Regras de estilo condicionais por coluna (experimental)
      * Cada regra contém uma expressão/DSL em `condition` e o efeito visual a aplicar.
@@ -165,6 +691,8 @@ interface ConfigMetadata {
     updatedAt?: string;
     /** Autor da configuração */
     author?: string;
+    /** Ambiente de execução esperado para política de runtime (ex.: dev, hml, prod) */
+    environment?: 'dev' | 'hml' | 'prod' | 'qa' | 'staging' | string;
     /** Se é um template ou configuração específica */
     isTemplate?: boolean;
     /** Configuração derivada de outra (parent ID) */
@@ -206,6 +734,163 @@ interface TableBehaviorConfig {
     resizing?: ResizingConfig;
     /** Configurações de reorganização por drag & drop */
     dragging?: DraggingConfig;
+    /** Configurações do modo local via input `[data]` */
+    localDataMode?: TableLocalDataModeConfig;
+    /** Configurações de linhas expansíveis (detail rows) */
+    expansion?: TableExpansionConfig;
+}
+interface TableLocalDataModeConfig {
+    /** Habilita a trilha de modo local via input `[data]` */
+    enabled?: boolean;
+}
+interface TableExpansionConfig {
+    /** Habilita o recurso de expansão de linhas */
+    enabled?: boolean;
+    /** Versão local do contrato de expansão */
+    contractVersion?: '1.0.0' | string;
+    /** Identidade e rastreabilidade de linha expandível */
+    identity?: {
+        rowKeySource?: 'table.idField';
+        requireStableIdField?: boolean;
+    };
+    /** Governança de estado (controlado vs não-controlado) */
+    state?: {
+        mode?: 'controlled' | 'uncontrolled';
+        expandedRowKeys?: string[];
+        emitChanges?: boolean;
+        sourceOfTruth?: 'input' | 'runtime';
+        onSetExpandedKeys?: 'emitOnly' | 'mutateInternal';
+    };
+    /** Regras de interação para abrir/fechar detalhes */
+    interaction?: {
+        trigger?: 'icon' | 'row' | 'both';
+        toggleOnRowClick?: boolean;
+        keyboard?: {
+            profile?: 'disclosure' | 'grid';
+            enterSpace?: boolean;
+            arrowLeftRight?: boolean;
+        };
+    };
+    /** Limites de expansão simultânea */
+    limits?: {
+        allowMultiple?: boolean;
+        maxExpandedRows?: number;
+        onOverflow?: 'collapseOldest' | 'denyNew' | 'collapseAll';
+    };
+    /** Eventos estruturais que colapsam os detalhes */
+    collapseOn?: {
+        sortChange?: boolean;
+        pageChange?: boolean;
+        filterChange?: boolean;
+        dataRefresh?: boolean;
+    };
+    /** Condição para permitir expansão por linha */
+    rowExpandableWhen?: {
+        expr?: string;
+        onError?: 'deny' | 'allow';
+        context?: Array<'row' | 'computed' | 'user' | 'env'>;
+    };
+    /** Detalhe schema-driven (fonte + renderização) */
+    detail?: {
+        schemaContract?: {
+            kind?: 'praxis.detail.schema';
+            version?: string;
+            compat?: 'semver' | 'strict';
+            allowedNodes?: Array<'layout' | 'stack' | 'tabs' | 'tab' | 'card' | 'value' | 'action' | 'list' | 'formRef' | 'tableRef' | 'chartRef' | 'richText' | 'templateRef'>;
+            sanitization?: 'strict';
+        };
+        source?: {
+            mode?: 'inline' | 'resource' | 'resourcePath';
+            inlineSchema?: Record<string, unknown>;
+            resource?: {
+                kind?: 'ui-composition' | 'form-schema' | 'table-schema' | 'dashboard-schema';
+                id?: string;
+                version?: string;
+            };
+            resourcePath?: {
+                path?: string;
+                paramsMap?: Record<string, string>;
+                method?: 'GET' | 'POST';
+            };
+            contextMap?: Record<string, string>;
+            resourceAllowList?: string[];
+            fallbackMode?: 'none' | 'inline' | 'resource';
+        };
+        rendering?: {
+            strategy?: 'registry';
+            registryId?: string;
+            hostLayout?: 'auto' | 'stack' | 'tabs';
+            fallbackNodePolicy?: 'failClosed' | 'renderPlaceholder';
+        };
+        height?: {
+            mode?: 'fixed' | 'dynamic';
+            px?: number;
+        };
+        lazyLoad?: {
+            enabled?: boolean;
+            actionId?: string;
+            cache?: {
+                enabled?: boolean;
+                ttlMs?: number;
+            };
+            retry?: {
+                maxAttempts?: number;
+            };
+            cancelOnCollapse?: boolean;
+            dedupeByRowKey?: boolean;
+        };
+    };
+    /** Política extra para coexistência com virtualização */
+    virtualization?: {
+        policy?: 'fixed-height-only' | 'allow-dynamic-under-flag';
+    };
+    /** Persistência de estado expandido */
+    persistence?: {
+        enabled?: boolean;
+        storageKey?: string;
+        storageKeyStrategy?: {
+            namespace?: string;
+            version?: string;
+            hashScope?: boolean;
+        };
+        scope?: Array<'tableId' | 'componentInstance' | 'user' | 'tenant'>;
+        clearOn?: Array<'resetPreferences' | 'logout' | 'tenantChange'>;
+    };
+    /** Segurança de payload/evento */
+    security?: {
+        eventExposureDefault?: {
+            rowId?: 'redacted' | 'hashed' | 'raw';
+            expandedKeys?: 'none' | 'hashed' | 'raw';
+        };
+        allowRawExposure?: boolean;
+    };
+    /** Deep-link de expansão (P1+) */
+    deepLink?: {
+        enabled?: boolean;
+        queryParam?: string;
+        encoding?: 'csv';
+        keyFormat?: string;
+        maxKeys?: number;
+        maxLength?: number;
+        parsing?: {
+            duplicateParams?: 'firstWins' | 'reject';
+            decodePasses?: 1;
+            trimWhitespace?: boolean;
+            sortKeysBeforeApply?: boolean;
+        };
+        integrity?: {
+            mode?: 'opaqueToken';
+            exchange?: {
+                endpointId?: string;
+                ttlMs?: number;
+                errors?: Array<'expired' | 'invalid' | 'rate_limited'>;
+            };
+        };
+        privacy?: {
+            mode?: 'denyByDefault' | 'allowByDefault';
+            allowListTables?: string[];
+        };
+    };
 }
 interface PaginationConfig {
     /** Habilitar paginação */
@@ -289,20 +974,54 @@ interface FilteringConfig {
         savePresets?: boolean;
         /** Configurações específicas do componente praxis-filter */
         settings?: {
-            /** Campo de busca rápida */
-            quickField?: string;
             /** Campos sempre visíveis */
             alwaysVisibleFields?: string[];
-            /** Placeholder da busca */
-            placeholder?: string;
+            /** Overrides de metadata por campo sempre visível (merge sobre o DTO de filtro) */
+            alwaysVisibleFieldMetadataOverrides?: Record<string, Record<string, any>>;
+            /** Campos extras selecionados pelo usuário */
+            selectedFieldIds?: string[];
             /** Exibir opções avançadas por padrão */
             showAdvanced?: boolean;
             /** Permitir salvar tags/atalhos de filtro */
             allowSaveTags?: boolean;
             /** Debounce de alterações para auto-aplicar filtros (ms) */
             changeDebounceMs?: number;
-            /** Modo de exibição do componente de filtro */
-            mode?: 'auto' | 'filter' | 'card';
+            /** Modo de exibição do componente de filtro (modo único) */
+            mode?: 'filter';
+            /** UX: move booleans para ações */
+            placeBooleansInActions?: boolean;
+            /** UX: mostrar labels dos toggles */
+            showToggleLabels?: boolean;
+            /** Largura mínima para campos sempre visíveis */
+            alwaysMinWidth?: number;
+            /** Colunas md para campos sempre visíveis */
+            alwaysColsMd?: number;
+            /** Colunas lg para campos sempre visíveis */
+            alwaysColsLg?: number;
+            /** Confirma remoção de tags */
+            confirmTagDelete?: boolean;
+            /** Tema das tags */
+            tagColor?: 'primary' | 'accent' | 'warn' | 'basic';
+            /** Variante das tags */
+            tagVariant?: 'filled' | 'outlined';
+            /** Cor do botão das tags */
+            tagButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+            /** Cor dos botões de ação */
+            actionsButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+            /** Variante dos botões de ação */
+            actionsVariant?: 'standard' | 'outlined';
+            /** Aparência do overlay */
+            overlayVariant?: 'card' | 'frosted';
+            /** Backdrop do overlay */
+            overlayBackdrop?: boolean;
+            /** Modo de abertura do painel avançado */
+            advancedOpenMode?: 'overlay' | 'modal' | 'drawer';
+            /** Botão de limpar nos campos do formulário avançado */
+            advancedClearButtonsEnabled?: boolean;
+            /** Nível de log */
+            logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+            /** Métricas de performance */
+            enablePerformanceMetrics?: boolean;
         };
     };
     /** Estratégia de filtragem */
@@ -605,6 +1324,10 @@ interface ToolbarConfig {
     visible: boolean;
     /** Posição da toolbar */
     position: 'top' | 'bottom' | 'both';
+    /** Posição das ações da toolbar */
+    actionsPosition?: 'top' | 'bottom' | 'both';
+    /** Cor de fundo da barra de ações */
+    actionsBackgroundColor?: string;
     /** Configurações de layout */
     layout?: ToolbarLayoutConfig;
     /** Título da tabela */
@@ -651,6 +1374,8 @@ interface ToolbarAction {
     tooltip?: string;
     /** Tecla de atalho */
     shortcut?: string;
+    /** Escopo do atalho: somente toolbar ativa ou global */
+    shortcutScope?: 'toolbar' | 'global';
     /** Posição na toolbar */
     position: 'start' | 'end';
     /** Ordem de exibição */
@@ -1441,6 +2166,9 @@ interface GlobalDialogAction {
     role?: 'primary' | 'secondary' | 'danger' | 'close' | 'custom';
     close?: boolean;
     icon?: string | null;
+    svgIcon?: string | null;
+    fillMode?: 'solid' | 'flat' | 'outline';
+    themeColor?: 'primary' | 'accent' | 'warn' | 'neutral';
     cssClass?: string | string[] | Record<string, boolean>;
 }
 interface GlobalDialogAnimation {
@@ -1456,443 +2184,196 @@ interface GlobalDialogStyles {
     containerMaxWidth?: string;
     containerMinWidth?: string;
     containerShape?: string;
+    containerBorderColor?: string;
     containerSmallMaxWidth?: string;
     contentPadding?: string;
-    headlinePadding?: string;
-    withActionsContentPadding?: string;
-    containerColor?: string;
-    subheadColor?: string;
-    supportingTextColor?: string;
-    subheadFont?: string;
-    subheadLineHeight?: string;
-    subheadSize?: string;
-    subheadTracking?: string;
-    subheadWeight?: string | number;
-    supportingTextFont?: string;
-    supportingTextLineHeight?: string;
-    supportingTextSize?: string;
-    supportingTextTracking?: string;
-    supportingTextWeight?: string | number;
-}
-interface GlobalDialogConfigEntry {
-    title?: string;
-    ariaRole?: GlobalDialogAriaRole;
-    message?: string;
-    icon?: string | null;
-    width?: string | number | null;
-    height?: string | number | null;
-    minWidth?: string | number | null;
-    maxWidth?: string | number | null;
-    minHeight?: string | number | null;
-    maxHeight?: string | number | null;
-    disableClose?: boolean;
-    hasBackdrop?: boolean;
-    closeOnBackdropClick?: boolean;
-    panelClass?: string | string[] | Record<string, boolean>;
-    backdropClass?: string | string[] | Record<string, boolean>;
-    position?: GlobalDialogPosition;
-    animation?: boolean | GlobalDialogAnimation;
-    styles?: GlobalDialogStyles;
-    actions?: GlobalDialogAction[];
-}
-interface GlobalDialogConfig {
-    defaults?: {
-        confirm?: GlobalDialogConfigEntry;
-        alert?: GlobalDialogConfigEntry;
-        prompt?: GlobalDialogConfigEntry;
-    };
-    variants?: Record<string, GlobalDialogConfigEntry>;
-}
-
-type FormOpenMode = 'route' | 'modal' | 'drawer';
-interface GlobalCrudActionDefaults {
-    openMode?: FormOpenMode;
-    route?: string;
-    formId?: string;
-}
-interface GlobalCrudDefaults {
-    openMode?: FormOpenMode;
-    modal?: Record<string, any>;
-    back?: Record<string, any>;
-    header?: Record<string, any>;
-}
-interface GlobalCrudConfig {
-    defaults?: GlobalCrudDefaults;
-    actionDefaults?: Record<string, GlobalCrudActionDefaults>;
-}
-interface GlobalDynamicFieldsAsyncSelectConfig {
-    loadOn?: 'open' | 'init' | 'none';
-    pageSize?: number;
-    useCursor?: boolean;
-}
-interface GlobalDynamicFieldsCascadeConfig {
-    enable?: boolean;
-    loadOnChange?: 'respectLoadOn' | 'immediate' | 'manual';
-    debounceMs?: number;
-}
-interface GlobalDynamicFieldsConfig {
-    asyncSelect?: GlobalDynamicFieldsAsyncSelectConfig;
-    cascade?: GlobalDynamicFieldsCascadeConfig;
-}
-type GlobalTableConfig = (Partial<Pick<TableConfig, 'behavior' | 'appearance' | 'toolbar' | 'actions' | 'messages' | 'localization' | 'performance'>> & {
-    /** UI defaults specific to the PraxisFilter (above the table) */
-    filteringUi?: {
-        overlayVariant?: 'card' | 'frosted';
-        overlayBackdrop?: boolean;
-        advancedOpenMode?: 'overlay' | 'modal' | 'drawer';
-    };
-});
-interface GlobalConfig {
-    crud?: GlobalCrudConfig;
-    dynamicFields?: GlobalDynamicFieldsConfig;
-    table?: GlobalTableConfig;
-    dialog?: GlobalDialogConfig;
-}
-
-declare const GLOBAL_CONFIG: InjectionToken<Partial<GlobalConfig>>;
-declare function provideGlobalConfig(partial: Partial<GlobalConfig>): Provider;
-
-/** Set the current tenant for GlobalConfigService at app boot. */
-declare function provideGlobalConfigTenant(tenantId: string): Provider;
-/** Seed global config once when no storage exists yet (idempotent). */
-declare function provideGlobalConfigSeed(seed: Partial<GlobalConfig>): Provider;
-/** Fetch remote JSON and merge as global config at boot. */
-declare function provideRemoteGlobalConfig(url: string): Provider;
-
-interface SettingsPanelRef<T = any> {
-    applied$: Observable<T>;
-    saved$: Observable<T>;
-}
-interface SettingsPanelOpenContent<TInputs = any> {
-    component: Type<any>;
-    inputs?: TInputs;
-}
-interface SettingsPanelOpenOptions<TInputs = any> {
-    id: string;
-    title: string;
-    content: SettingsPanelOpenContent<TInputs>;
-}
-interface SettingsPanelBridge {
-    open<TInputs = any, TOut = any>(opts: SettingsPanelOpenOptions<TInputs>): SettingsPanelRef<TOut>;
-}
-declare const SETTINGS_PANEL_BRIDGE: InjectionToken<SettingsPanelBridge>;
-declare const SETTINGS_PANEL_DATA: InjectionToken<any>;
-interface SettingsValueProvider {
-    isDirty$: Observable<boolean>;
-    isValid$: Observable<boolean>;
-    isBusy$: Observable<boolean>;
-    getSettingsValue(): any;
-    onSave?(): any;
-    reset?(): void;
-}
-
-declare const TABLE_CONFIG_EDITOR: InjectionToken<Type<any>>;
-declare const STEPPER_CONFIG_EDITOR: InjectionToken<Type<any>>;
-
-interface HateoasLink {
-    href: string;
-    templated?: boolean;
-    type?: string;
-    deprecation?: string;
-    profile?: string;
-    name?: string;
-    title?: string;
-    hreflang?: string;
-    [prop: string]: any;
-}
-interface RestApiLinks {
-    [rel: string]: HateoasLink | HateoasLink[];
-}
-interface RestApiResponse<T> {
-    status?: string;
-    message?: string;
-    data: T;
-    _links?: RestApiLinks;
-    errors?: any;
-    timestamp?: string;
-}
-
-interface Page<T> {
-    content: T[];
-    totalElements: number;
-    totalPages: number;
-    size: number;
-    number: number;
-}
-interface CursorPage<T> {
-    content: T[];
-    next?: string | null;
-    prev?: string | null;
-    size: number;
-}
-
-interface OptionDTO<ID = string | number> {
-    id: ID;
-    label: string;
-    extra?: Record<string, unknown>;
-}
-
-interface PageableRequest {
-    pageNumber: number;
-    pageSize: number;
-    sort?: string[];
-}
-interface FilterOptions<ID = string | number> {
-    includeIds?: ID[];
-    observeVersionHeader?: boolean;
-}
-interface CursorRequest {
-    size?: number;
-    sort?: string[];
-    after?: string | null;
-    before?: string | null;
-}
-interface LocateRequest {
-    size: number;
-    sort?: string[];
-}
-
-/**
- * Contrato de saída do normalizador de esquema (SchemaNormalizerService):
- * - Converte metadados `x-ui` em FieldDefinition tipado.
- * - Todas as funções expostas são funções reais (nunca strings):
- *   - conditionalDisplay: () => boolean
- *   - conditionalRequired: () => boolean
- *   - transformValueFunction: (val: any) => any
- * - Suporte completo a ValidatorOptions (sincronos e assíncronos),
- *   incluindo mensagens e comportamento de validação (gatilhos, debounce, exibição de erros).
- */
-interface FieldDefinition {
-    name: string;
-    label?: string;
-    description?: string;
-    type?: string;
-    controlType?: string;
-    placeholder?: string;
-    defaultValue?: any;
-    group?: string;
-    order?: number;
-    width?: number | string;
-    isFlex?: boolean;
-    displayOrientation?: string;
-    disabled?: boolean;
-    readOnly?: boolean;
-    multiple?: boolean;
-    editable?: boolean;
-    validationMode?: string;
-    unique?: boolean;
-    mask?: string;
-    sortable?: boolean;
-    /** Função que define obrigatoriedade condicional. */
-    conditionalRequired?: () => boolean;
-    viewOnlyStyle?: string;
-    /** Lista de gatilhos de validação, ex.: ["blur", "change"]. */
-    validationTriggers?: string[];
-    hidden?: boolean;
-    tableHidden?: boolean;
-    formHidden?: boolean;
-    filterable?: boolean;
-    /** Função que controla se o campo é exibido. */
-    conditionalDisplay?: () => boolean;
-    dependentField?: string;
-    resetOnDependentChange?: boolean;
-    inlineEditing?: boolean;
-    /** Função de transformação de valor antes de salvar/exibir. */
-    transformValueFunction?: (val: any) => any;
-    debounceTime?: number;
-    helpText?: string;
-    hint?: string;
-    hiddenCondition?: any;
-    tooltipOnHover?: boolean;
-    icon?: string;
-    iconPosition?: string;
-    iconSize?: string | number;
-    iconColor?: string;
-    iconClass?: string;
-    iconStyle?: string;
-    iconFontSize?: string | number;
-    valueField?: string;
-    displayField?: string;
-    endpoint?: string;
-    resourcePath?: string;
-    emptyOptionText?: string;
-    options?: {
-        key: string;
-        value: string;
-    }[];
-    filter?: any;
-    filterCriteria?: any;
-    searchable?: boolean;
-    selectAll?: boolean;
-    maxSelections?: number;
-    optionLabelKey?: string;
-    optionValueKey?: string;
-    filterOptions?: any[];
-    filterControlType?: string;
-    numericFormat?: string;
-    numericStep?: number;
-    numericMin?: number;
-    numericMax?: number;
-    numericMaxLength?: number;
-    optionGroups?: {
-        key: string;
-        value: string;
-    }[];
-    disabledOptions?: string[];
-    buttons?: any[];
-    /** Obrigatório. */
-    required?: boolean;
-    requiredMessage?: string;
-    /** Tamanho mínimo/máximo (strings). */
-    minLength?: number;
-    minLengthMessage?: string;
-    maxLength?: number;
-    maxLengthMessage?: string;
-    /** Limites numéricos. */
-    min?: number;
-    max?: number;
-    /** Mensagens dedicadas para min/max numéricos. */
-    minMessage?: string;
-    maxMessage?: string;
-    /** Mensagem quando ambos limites (range) são aplicados. */
-    rangeMessage?: string;
-    /** Padrão (regex). Aceita pattern/regex. */
-    pattern?: string;
-    patternMessage?: string;
-    /** Validação de e-mail. */
-    email?: boolean;
-    emailMessage?: string;
-    /** Validação de URL. */
-    url?: boolean;
-    urlMessage?: string;
-    /** Requer que valor combine com outro campo. */
-    matchField?: string;
-    matchFieldMessage?: string;
-    /** Requer que o checkbox esteja marcado. */
-    requiredChecked?: boolean;
-    /** Tipos de arquivo permitidos e tamanho máximo. */
-    allowedFileTypes?: string[];
-    fileTypeMessage?: string;
-    maxFileSize?: number;
-    /** Validador customizado síncrono. */
-    customValidator?: (value: any, model?: any) => any;
-    /** Validador customizado assíncrono. */
-    asyncValidator?: (value: any, model?: any) => Promise<any>;
-    /** Validador de unicidade (ex.: consulta ao backend). */
-    uniqueValidator?: (value: any, model?: any) => boolean | Promise<boolean>;
-    uniqueMessage?: string;
-    /** Validação condicional baseada em outro(s) campos/estado. */
-    conditionalValidation?: (value: any, model?: any) => boolean | string | Promise<boolean | string>;
-    /** Mínimo de palavras (para textos longos). */
-    minWords?: number;
-    /** Gatilho(s) de validação (alias de validationTriggers). */
-    /** Tempo de debounce (ms) para executar validação. */
-    validationDebounce?: number;
-    /** Exibir erros inline no campo. */
-    showInlineErrors?: boolean;
-    /** Posição preferida da mensagem de erro (ex.: below, right). */
-    errorPosition?: string;
-    [key: string]: any;
+    headlinePadding?: string;
+    withActionsContentPadding?: string;
+    backdropColor?: string;
+    actionButtonRadius?: string;
+    actionButtonMinHeight?: string;
+    actionButtonPadding?: string;
+    containerColor?: string;
+    subheadColor?: string;
+    supportingTextColor?: string;
+    subheadFont?: string;
+    subheadLineHeight?: string;
+    subheadSize?: string;
+    subheadTracking?: string;
+    subheadWeight?: string | number;
+    supportingTextFont?: string;
+    supportingTextLineHeight?: string;
+    supportingTextSize?: string;
+    supportingTextTracking?: string;
+    supportingTextWeight?: string | number;
 }
-
-declare enum ApiEndpoint {
-    Default = "default",
-    HumanResources = "humanResources",
-    UiWrappersTest = "uiWrappersTest"
+interface GlobalDialogConfigEntry {
+    title?: string;
+    themeColor?: 'primary' | 'light' | 'dark';
+    ariaRole?: GlobalDialogAriaRole;
+    message?: string;
+    icon?: string | null;
+    width?: string | number | null;
+    height?: string | number | null;
+    minWidth?: string | number | null;
+    maxWidth?: string | number | null;
+    minHeight?: string | number | null;
+    maxHeight?: string | number | null;
+    disableClose?: boolean;
+    hasBackdrop?: boolean;
+    closeOnBackdropClick?: boolean;
+    panelClass?: string | string[] | Record<string, boolean>;
+    backdropClass?: string | string[] | Record<string, boolean>;
+    position?: GlobalDialogPosition;
+    animation?: boolean | GlobalDialogAnimation;
+    styles?: GlobalDialogStyles;
+    actions?: GlobalDialogAction[];
+}
+interface GlobalDialogConfig {
+    defaults?: {
+        confirm?: GlobalDialogConfigEntry;
+        alert?: GlobalDialogConfigEntry;
+        prompt?: GlobalDialogConfigEntry;
+    };
+    variants?: Record<string, GlobalDialogConfigEntry>;
 }
 
-/**
- * SchemaNormalizerService
- * -----------------------
- * Serviço responsável por converter um esquema bruto (OpenAPI + x-ui) em uma
- * lista tipada de FieldDefinition consumida pelo restante do sistema
- * (mapeadores de metadata, criador de FormGroup, carregador de campos dinâmicos, etc.).
- *
- * Entrada esperada
- * - Objeto JSON no formato OpenAPI/JSON Schema contendo:
- *   - properties: { [name: string]: { type, title, description, ... , 'x-ui': { ... } } }
- *   - Em cada propriedade, o objeto 'x-ui' define aspectos de UI/validação.
- *
- * Saída (FieldDefinition[])
- * - Tipagem forte de campos com funções reais (nunca strings) para regras condicionais e validadores customizados.
- * - Todas as propriedades de validação e comportamento consolidadas no mesmo objeto do campo.
- *
- * Segurança e observações
- * - Este serviço aceita funções em formato string dentro do x-ui (ex.: uniqueValidator, conditionalValidation),
- *   e as converte via new Function. Isso exige backend confiável e controlado.
- *   Em ambientes não confiáveis, evite funções como string ou implemente um sandbox/whitelist.
- * - Valores booleanos/numéricos são normalizados para tipos nativos.
- * - Arrays de opções são convertidos para pares { key, value } previsíveis.
- *
- * Exemplo mínimo de entrada
- * const schema = {
- *   properties: {
- *     email: {
- *       type: 'string',
- *       title: 'E-mail',
- *       'x-ui': { controlType: 'input', type: 'string', required: true, email: true }
- *     }
- *   }
- * };
- * const fields = normalizer.normalizeSchema(schema);
- * // fields: [{ name: 'email', label: 'E-mail', type: 'string', controlType: 'input', required: true, email: true }]
- */
-declare class SchemaNormalizerService {
-    /** Convert value to boolean. Accepts boolean, string or number. */
-    private parseBoolean;
-    /** Ensure an array of strings from various inputs. */
-    private parseStringArray;
-    /** Parse option arrays into `{ key, value }` objects. */
-    private parseOptions;
-    /**
-     * Converte string/Function em função real.
-     * Atenção: usa `new Function` para avaliar strings – requer backend confiável.
-     */
-    private parseFunction;
-    /** Parse a predicate function: () => boolean */
-    private parsePredicateFunction;
-    /** Parse a transform function: (val: any) => any */
-    private parseTransformFunction;
+type FormOpenMode = 'route' | 'modal' | 'drawer';
+interface GlobalCrudActionDefaults {
+    openMode?: FormOpenMode;
+    route?: string;
+    formId?: string;
+}
+interface GlobalCrudDefaults {
+    openMode?: FormOpenMode;
+    modal?: Record<string, any>;
+    back?: Record<string, any>;
+    header?: Record<string, any>;
     /**
-     * Parse de validador condicional: (value: any, model?: any) => boolean | string | Promise<boolean | string>
+     * Quando usado via <praxis-crud>, habilita automaticamente a coluna de ações por linha
+     * com base nas ações declaradas (ex.: view/edit). Desligue para controlar manualmente.
+     * Default: true
      */
-    private parseConditionalValidator;
+    autoRowActions?: boolean;
     /**
-     * Extrai e normaliza propriedades de validação a partir do objeto x-ui.
-     * Suporta: required, min/max, minLength/maxLength, pattern/regex, email, url,
-     * matchField, uniqueValidator (+message), conditionalValidation, requiredChecked,
-     * arquivos (allowedFileTypes, fileTypeMessage, maxFileSize), custom/async validators,
-     * minWords e comportamento (validationTrigger(s), validationDebounce, showInlineErrors, errorPosition).
+     * Formato padrão para exibição das ações de linha geradas automaticamente.
+     * Default: 'icons'
      */
-    private parseValidators;
-    /** Parse array of button definitions. */
-    private parseButtons;
+    rowActionsDisplay?: 'icons' | 'buttons' | 'menu';
     /**
-     * Converte o schema bruto do backend (OpenAPI + x-ui) em FieldDefinition[] tipado.
-     * Regras:
-     * - Ignora propriedades sem x-ui.
-     * - Garante ordenação por 'order' quando presente.
-     * - Funções condicionais/transformações sempre viram funções reais.
-     *
-     * @param schema Objeto OpenAPI/JSON Schema com properties e x-ui por propriedade.
-     * @returns FieldDefinition[] prontos para mapeamento/uso no restante do sistema.
+     * Inclui ação de delete na coluna de ações quando houver ação 'delete' declarada.
+     * Por padrão permanece desabilitado para evitar comportamentos não intencionais.
      */
-    normalizeSchema(schema: any): FieldDefinition[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaNormalizerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaNormalizerService>;
+    includeDeleteInRow?: boolean;
+}
+interface GlobalCrudConfig {
+    defaults?: GlobalCrudDefaults;
+    actionDefaults?: Record<string, GlobalCrudActionDefaults>;
+}
+interface GlobalDynamicFieldsAsyncSelectConfig {
+    loadOn?: 'open' | 'init' | 'none';
+    pageSize?: number;
+    useCursor?: boolean;
+}
+interface GlobalDynamicFieldsCascadeConfig {
+    enable?: boolean;
+    loadOnChange?: 'respectLoadOn' | 'immediate' | 'manual';
+    debounceMs?: number;
+}
+interface GlobalDynamicFieldsConfig {
+    asyncSelect?: GlobalDynamicFieldsAsyncSelectConfig;
+    cascade?: GlobalDynamicFieldsCascadeConfig;
+}
+type GlobalTableConfig = (Partial<Pick<TableConfig, 'behavior' | 'appearance' | 'toolbar' | 'actions' | 'messages' | 'localization' | 'performance'>> & {
+    /** UI defaults specific to the PraxisFilter (above the table) */
+    filteringUi?: {
+        overlayVariant?: 'card' | 'frosted';
+        overlayBackdrop?: boolean;
+        advancedOpenMode?: 'overlay' | 'modal' | 'drawer';
+    };
+});
+type GlobalAiProvider = 'gemini' | 'openai' | 'xai' | 'mock';
+interface GlobalAiEmbeddingConfig {
+    useSameAsLlm?: boolean;
+    provider?: GlobalAiProvider;
+    apiKey?: string;
+    apiKeyLast4?: string;
+    hasApiKey?: boolean;
+    model?: string;
+    dimensions?: number;
+}
+interface GlobalAiConfig {
+    provider?: GlobalAiProvider;
+    /** Policy for UI confirmation on risky AI patches. */
+    riskPolicy?: 'strict' | 'standard';
+    apiKey?: string;
+    apiKeyLast4?: string;
+    hasApiKey?: boolean;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    embedding?: GlobalAiEmbeddingConfig;
+}
+interface GlobalCacheConfig {
+    /**
+     * Se verdadeiro, desabilita o cache persistente (LocalStorage) para schemas de metadados.
+     * Isso força o download do schema a cada recarga da aplicação, útil quando se deseja
+     * priorizar a configuração vinda do servidor ou durante desenvolvimento intenso de API.
+     * Default: false
+     */
+    disableSchemaCache?: boolean;
+}
+interface GlobalConfig {
+    crud?: GlobalCrudConfig;
+    dynamicFields?: GlobalDynamicFieldsConfig;
+    table?: GlobalTableConfig;
+    dialog?: GlobalDialogConfig;
+    /** Dynamic routes registered at runtime (host-resolved). */
+    routes?: {
+        dynamic?: Array<{
+            path: string;
+            componentId?: string;
+            loadChildren?: any;
+            data?: Record<string, any>;
+            resolve?: Record<string, any>;
+            guards?: string[];
+            canMatch?: string[];
+            canActivateChild?: string[];
+            replace?: boolean;
+            position?: 'append' | 'prepend' | 'before-wildcard';
+        }>;
+    };
+    ai?: GlobalAiConfig;
+    cache?: GlobalCacheConfig;
 }
 
 declare class GlobalConfigService {
     private readonly storage;
+    private readonly bootstrapReady;
+    private readonly tenantResolver;
+    private readonly bootstrapOptions;
     private tenant;
+    private configCache;
+    private configCacheKey;
+    private configLoadPromise;
+    private configLoadKey;
+    private storageSnapshot;
+    private storageSnapshotKey;
     private readonly providerPartials;
     private readonly changes$;
     /** Emits when the global configuration changes (e.g., saved to storage). */
     readonly configChanges$: rxjs.Observable<GlobalConfig | null>;
+    constructor();
     /** Returns merged global configuration using precedence: defaults < providers < storage */
     private buildConfig;
+    /** Blocks until the current global configuration (for the active tenant) is loaded. */
+    ready(): Promise<GlobalConfig | null>;
+    /** Ensure config cache is populated (fire-and-forget); resolves with last merged config. */
+    ensureConfigLoaded(opts?: {
+        silent?: boolean;
+    }): Promise<GlobalConfig | null>;
     /** Persist and broadcast a new global configuration, merged on top of providers. */
-    saveGlobalConfig(partial: Partial<GlobalConfig>): void;
+    saveGlobalConfig(partial: Partial<GlobalConfig>): Promise<void>;
     /**
      * Retrieve value at a dot-path (e.g., 'crud.defaults.openMode').
      * When no path is provided, returns the entire merged configuration.
@@ -1906,8 +2387,13 @@ declare class GlobalConfigService {
     setTenant(tenantId?: string): void;
     /** Get current tenant id (if any). */
     getTenant(): string | undefined;
+    clearGlobalConfig(): Promise<void>;
+    hasStoredConfig(): boolean;
     /** Compute the storage key considering current tenant */
     private storageKey;
+    private shouldFail;
+    private waitForBootstrap;
+    private updateStorageSnapshot;
     /**
      * Read global schema verification preferences.
      * Returns undefined when not set to allow callers to fallback to library defaults.
@@ -1969,6 +2455,7 @@ interface CrudOperationOptions {
     parentPath?: string;
     /** Chave do endpoint configurado via ApiUrlConfig */
     endpointKey?: ApiEndpoint;
+    httpContext?: HttpContext;
 }
 interface BatchDeleteProgress<ID = string | number> {
     id: ID;
@@ -2018,7 +2505,10 @@ declare class GenericCrudService<T, ID extends string | number = string | number
     private _schemaUrl;
     private configured;
     private _filterSchemaCache;
-    private _schemaCache;
+    private _rangeFilterFieldHints;
+    private _filterSchemaLoaded;
+    private _schemaCache?;
+    private schemaCacheReady?;
     private _lastResourceMeta;
     private _lastSchemaInfo;
     /**
@@ -2029,6 +2519,7 @@ declare class GenericCrudService<T, ID extends string | number = string | number
      * @param apiUrlInjected URL base da API (via token de injeção).
      */
     constructor(http: HttpClient, schemaNormalizer: SchemaNormalizerService, globalConfig: GlobalConfigService, apiUrlInjected: ApiUrlConfig);
+    private ensureSchemaCacheReady;
     private get errorMessages();
     configure(resourcePath: string, endpointKey?: ApiEndpoint): void;
     /**
@@ -2118,6 +2609,8 @@ declare class GenericCrudService<T, ID extends string | number = string | number
         operation?: string;
         includeInternalSchemas?: boolean;
         schemaType?: string;
+        endpointKey?: ApiEndpoint;
+        httpContext?: HttpContext;
     }): Observable<FieldDefinition[]>;
     /**
      * Retorna todos os registros do recurso.
@@ -2322,6 +2815,31 @@ declare class GenericCrudService<T, ID extends string | number = string | number
      * Resolve `/schemas/filtered` base URL honoring ApiUrlConfig (supports APIs on another origin).
      */
     getSchemasFilteredBaseUrl(endpointKey?: ApiEndpoint): string;
+    private normalizeRangeCriteria;
+    private normalizeRangeNode;
+    private tryCollapseRangeObject;
+    private coerceBoundsArray;
+    private buildCanonicalBounds;
+    private shouldSwapBounds;
+    private tryParseNumeric;
+    private tryParseDateMillis;
+    private isRangeOnlyObject;
+    private resolveRangeAliases;
+    private findExistingKey;
+    private normalizeRangeBound;
+    private isRangeValue;
+    private isPlainObject;
+    private updateRangeFieldHints;
+    private hasRangeFieldMetadata;
+    private normalizeControlTypeToken;
+    private isRangeControlType;
+    private looksLikeRangeFieldName;
+    private lowerDateAliases;
+    private upperDateAliases;
+    private lowerMoneyAliases;
+    private upperMoneyAliases;
+    private lowerGenericAliases;
+    private upperGenericAliases;
     /**
      * Manipula erros de requisição HTTP.
      */
@@ -2491,36 +3009,307 @@ interface ConfigStorage {
     saveConfig<T>(key: string, config: T): void;
     clearConfig(key: string): void;
 }
+/**
+ * Async contract for config storage (HTTP-friendly).
+ */
+interface AsyncConfigStorage {
+    /**
+     * Reads config for a key.
+     *
+     * Success contract:
+     * - emit one `next` value (can be `null`) and complete.
+     * Failure contract:
+     * - emit `error`.
+     */
+    loadConfig<T>(key: string): Observable<T | null>;
+    /**
+     * Persists config for a key.
+     *
+     * Success contract (strong ack):
+     * - emit at least one `next` (typically `void 0`) and then complete.
+     * Not-acknowledged contract (soft-fail path):
+     * - complete without any `next`.
+     * Hard-failure contract:
+     * - emit `error`.
+     *
+     * Important:
+     * - table runtime treats complete without `next` as
+     *   "persistence not acknowledged".
+     */
+    saveConfig<T>(key: string, config: T): Observable<void>;
+    /**
+     * Clears config for a key.
+     *
+     * Success contract (strong ack):
+     * - emit at least one `next` (typically `void 0`) and then complete.
+     * Not-acknowledged contract (soft-fail path):
+     * - complete without any `next`.
+     * Hard-failure contract:
+     * - emit `error`.
+     *
+     * Important:
+     * - table runtime treats complete without `next` as
+     *   "clear not acknowledged".
+     */
+    clearConfig(key: string): Observable<void>;
+}
 declare class LocalStorageConfigService implements ConfigStorage {
     loadConfig<T>(key: string): T | null;
     saveConfig<T>(key: string, config: T): void;
     clearConfig(key: string): void;
+    trySaveConfig<T>(key: string, config: T): boolean;
+    tryClearConfig(key: string): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageConfigService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageConfigService>;
 }
-declare const CONFIG_STORAGE: InjectionToken<ConfigStorage>;
-
-interface ConnectionConfigV1 {
-    resourcePath: string;
-    version: 1;
-    updatedAt: string;
-    origin?: 'quick-connect' | 'editor' | 'input';
+/**
+ * Async adapter over the sync LocalStorage service.
+ */
+declare class LocalStorageAsyncAdapter implements AsyncConfigStorage {
+    private readonly delegate;
+    constructor(delegate: LocalStorageConfigService);
+    loadConfig<T>(key: string): Observable<T | null>;
+    saveConfig<T>(key: string, config: T): Observable<void>;
+    clearConfig(key: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageAsyncAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageAsyncAdapter>;
+}
+/**
+ * Defers async storage operations until a gate resolves.
+ * Useful to ensure auth/tenant context is ready before HTTP requests.
+ */
+declare class DeferredAsyncConfigStorage implements AsyncConfigStorage {
+    private readonly delegate;
+    private readonly gate?;
+    constructor(delegate: AsyncConfigStorage, gate?: (() => Promise<void>) | undefined);
+    loadConfig<T>(key: string): Observable<T | null>;
+    saveConfig<T>(key: string, config: T): Observable<void>;
+    clearConfig(key: string): Observable<void>;
+}
+declare const ASYNC_CONFIG_STORAGE: InjectionToken<AsyncConfigStorage>;
+declare class RemoteConfigStorage implements ConfigStorage {
+    private readonly asyncStorage;
+    private readonly localStorage;
+    private readonly cache;
+    private readonly inflight;
+    loadConfig<T>(key: string): T | null;
+    saveConfig<T>(key: string, config: T): void;
+    clearConfig(key: string): void;
+    private refreshRemote;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteConfigStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemoteConfigStorage>;
+}
+declare const CONFIG_STORAGE: InjectionToken<ConfigStorage>;
+/**
+ * Options for ApiConfigStorage.
+ */
+interface ApiConfigStorageOptions {
+    baseUrl?: string;
+    /** Factory to supply headers (tenant/user/env/updatedBy) per request. */
+    headersFactory?: () => Record<string, string | undefined>;
+    /** Default headers applied when the headersFactory omits them. */
+    defaultHeaders?: Record<string, string>;
+    /** Resolve componentType from the storage key (use the component selector, e.g. praxis-table). */
+    componentTypeResolver?: (key: string) => string;
+    /** Controls whether load errors for global config should propagate. */
+    errorPolicy?: 'fail' | 'ignore';
+}
+declare const API_CONFIG_STORAGE_OPTIONS: InjectionToken<ApiConfigStorageOptions>;
+/**
+ * HTTP-based storage that talks to praxis-config-starter user-config API.
+ */
+declare class ApiConfigStorage implements AsyncConfigStorage {
+    private readonly http;
+    private readonly opts;
+    private readonly baseUrl;
+    private readonly headersFactory;
+    private readonly defaultHeaders;
+    private readonly componentTypeResolver;
+    private readonly cache;
+    constructor();
+    loadConfig<T>(key: string): Observable<T | null>;
+    saveConfig<T>(key: string, config: T): Observable<void>;
+    private shouldPropagateSaveError;
+    private shouldPropagateClearError;
+    private shouldPropagateLoadError;
+    private isCriticalPersistenceKey;
+    clearConfig(key: string): Observable<void>;
+    private buildHeaders;
+    private buildParams;
+    private resolveKey;
+    private inferComponentType;
+    private looksLikePageKey;
+    private stripQuotes;
+    private formatEtag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiConfigStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiConfigStorage>;
+}
+
+type GlobalActionResult = {
+    success: boolean;
+    data?: any;
+    error?: string;
+};
+type GlobalActionContext = {
+    sourceId?: string;
+    widgetKey?: string;
+    output?: string;
+    payload?: any;
+    pageContext?: Record<string, any> | null;
+    meta?: Record<string, any>;
+};
+type GlobalActionHandler = (payload?: any, context?: GlobalActionContext) => Promise<GlobalActionResult> | GlobalActionResult;
+interface GlobalActionHandlerEntry {
+    id: string;
+    handler: GlobalActionHandler;
+}
+interface GlobalDialogService {
+    alert: (payload: {
+        title?: string;
+        message?: string;
+        variant?: string;
+    }) => Promise<any> | any;
+    confirm: (payload: {
+        title?: string;
+        message?: string;
+        confirmLabel?: string;
+        cancelLabel?: string;
+        type?: 'danger' | 'warning' | 'info';
+    }) => Promise<boolean> | boolean;
+    prompt: (payload: {
+        title?: string;
+        message?: string;
+        placeholder?: string;
+        defaultValue?: string;
+    }) => Promise<any> | any;
+    open: (payload: {
+        componentId?: string;
+        inputs?: any;
+        size?: any;
+        data?: any;
+    }) => Promise<any> | any;
+}
+interface GlobalToastService {
+    success: (message: string, opts?: any) => void;
+    error: (message: string, opts?: any) => void;
+}
+interface GlobalAnalyticsService {
+    track: (eventName: string, payload?: any) => void;
+}
+interface GlobalApiClient {
+    get: (url: string, params?: Record<string, any>) => Promise<any> | any;
+    post: (url: string, body?: any) => Promise<any> | any;
+    patch: (url: string, body?: any) => Promise<any> | any;
+}
+interface GlobalRouteGuardResolver {
+    resolve: (guardId: string) => any;
+}
+
+declare class GlobalActionService {
+    private readonly handlers;
+    private readonly router;
+    private readonly location;
+    private readonly registry;
+    private readonly globalConfig;
+    private readonly dialog;
+    private readonly toast;
+    private readonly analytics;
+    private readonly api;
+    private readonly guardResolver;
+    constructor();
+    register(id: string, handler: GlobalActionHandler): void;
+    has(id: string): boolean;
+    execute(id: string, payload?: any, context?: GlobalActionContext): Promise<GlobalActionResult>;
+    private registerBuiltins;
+    private handleApi;
+    private handleRouteRegister;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalActionService>;
+}
+
+interface ConnectionConfigV1 {
+    resourcePath: string;
+    version: 1;
+    updatedAt: string;
+    origin?: 'quick-connect' | 'editor' | 'input';
+}
+interface ConnectionStorage {
+    loadConnection(key: string): Observable<ConnectionConfigV1 | null>;
+    saveConnection(key: string, cfg: ConnectionConfigV1): Observable<void>;
+    clearConnection(key: string): Observable<void>;
+}
+declare class LocalConnectionStorage implements ConnectionStorage {
+    private storage;
+    constructor(storage: AsyncConfigStorage);
+    loadConnection(key: string): Observable<ConnectionConfigV1 | null>;
+    saveConnection(key: string, cfg: ConnectionConfigV1): Observable<void>;
+    clearConnection(key: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalConnectionStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalConnectionStorage>;
+}
+declare const CONNECTION_STORAGE: InjectionToken<ConnectionStorage>;
+
+type DeviceKind = 'mobile' | 'tablet' | 'desktop';
+type OverlayPattern = 'modal' | 'drawer' | 'page' | 'bottom-sheet' | 'full-screen-dialog';
+interface OverlayDecisionContext {
+    device: DeviceKind;
+    fieldCount: number;
+    dependencyCount: number;
+}
+interface OverlayDecision {
+    pattern: OverlayPattern;
+    config?: Record<string, unknown>;
+    reason?: string;
+}
+interface OverlayRange {
+    min?: number;
+    max?: number;
+}
+interface OverlayRuleMatch {
+    device?: DeviceKind[];
+    fieldCount?: OverlayRange;
+    dependencyCount?: OverlayRange;
+    any?: OverlayRuleMatch[];
+}
+interface OverlayRule {
+    match: OverlayRuleMatch;
+    use: OverlayDecision;
+}
+interface OverlayThresholds {
+    fieldCount: {
+        small_max: number;
+        medium_max: number;
+    };
+    dependencyCount: {
+        low_max: number;
+        medium_max: number;
+    };
 }
-interface ConnectionStorage {
-    loadConnection(key: string): ConnectionConfigV1 | null;
-    saveConnection(key: string, cfg: ConnectionConfigV1): void;
-    clearConnection(key: string): void;
+interface OverlayDecisionMatrix {
+    version: string;
+    description?: string;
+    thresholds: OverlayThresholds;
+    rules_ordered: OverlayRule[];
+    fallback: OverlayDecision;
+    ui_hints?: Record<string, unknown>;
 }
-declare class LocalConnectionStorage implements ConnectionStorage {
-    private storage;
-    constructor(storage: ConfigStorage);
-    loadConnection(key: string): ConnectionConfigV1 | null;
-    saveConnection(key: string, cfg: ConnectionConfigV1): void;
-    clearConnection(key: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocalConnectionStorage, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LocalConnectionStorage>;
+interface OverlayDecider {
+    decide(ctx: OverlayDecisionContext): OverlayDecision;
+    explain?(ctx: OverlayDecisionContext): string;
+}
+
+declare const OVERLAY_DECIDER_DEBUG: InjectionToken<boolean>;
+declare class OverlayDeciderService {
+    private readonly matrix;
+    private readonly debug;
+    decide(ctx: OverlayDecisionContext): OverlayDecision;
+    explain(ctx: OverlayDecisionContext): string;
+    private evaluate;
+    private matches;
+    private log;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayDeciderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayDeciderService>;
 }
-declare const CONNECTION_STORAGE: InjectionToken<ConnectionStorage>;
 
 /**
  * Enum que define os tipos de dados (`TYPE`) disponíveis para configuração dos campos de formulário.
@@ -2551,6 +3340,7 @@ declare const FieldControlType: {
     readonly APP_BAR: "appBar";
     readonly ARC_GAUGE: "arcGauge";
     readonly ARRAY_INPUT: "array";
+    readonly ASYNC_SELECT: "async-select";
     readonly AUTO_COMPLETE: "autoComplete";
     readonly AVATAR: "avatar";
     readonly BARCODE_GENERATOR: "barcodeGenerator";
@@ -2624,6 +3414,7 @@ declare const FieldControlType: {
     readonly RIPPLE: "ripple";
     readonly SCROLL_VIEW: "scrollView";
     readonly SEARCH_INPUT: "search";
+    readonly SEARCHABLE_SELECT: "searchable-select";
     readonly SELECTION_LIST: "selectionList";
     readonly SELECT: "select";
     readonly SIGNATURE: "signature";
@@ -2945,6 +3736,10 @@ interface FieldMetadata extends ComponentMetadata {
     suffixIcon?: string;
     iconPosition?: 'start' | 'end';
     iconSize?: 'small' | 'medium' | 'large';
+    /** Tooltip for suffix icon (used for help actions) */
+    suffixIconTooltip?: string;
+    /** ARIA label for suffix icon when used as help */
+    suffixIconAriaLabel?: string;
     /** Input masking pattern */
     mask?: string;
     /** Format for display values */
@@ -3087,19 +3882,6 @@ type CoreFieldMetadata = Pick<FieldMetadata, 'name' | 'label' | 'controlType'>;
 /** Helper type for field metadata without computed properties */
 type SerializableFieldMetadata = Omit<FieldMetadata, 'conditionalRequired' | 'conditionalDisplay' | 'transformDisplayValue' | 'transformSaveValue'>;
 
-/**
- * @fileoverview Specialized metadata interfaces for Angular Material components
- *
- * This file extends the base FieldMetadata interface with component-specific
- * properties for each Material Design component type.
- *
- * Each interface follows the pattern:
- * - Extends FieldMetadata
- * - Adds component-specific properties
- * - Maintains type safety with literal types
- * - Supports Material Design 3 specifications
- */
-
 /**
  * Enhanced validation context with type safety
  * Provides comprehensive context for custom validation functions
@@ -3309,6 +4091,8 @@ interface MaterialInputMetadata extends BaseMaterialInputMetadata {
         enabled: boolean;
         /** Nome do ícone Material (default: 'clear') */
         icon?: string;
+        /** Cor do ícone (tema ou CSS) */
+        iconColor?: string;
         /** Posição fixa no 'end' conforme Material Design */
         position?: 'end';
         /** Tooltip text for accessibility */
@@ -3696,6 +4480,36 @@ interface MaterialNumericMetadata extends BaseMaterialInputMetadata {
     min?: number;
     /** Maximum allowed value */
     max?: number;
+    /** Minimum allowed value for start input */
+    startMin?: number;
+    /** Maximum allowed value for start input */
+    startMax?: number;
+    /** Minimum allowed value for end input */
+    endMin?: number;
+    /** Maximum allowed value for end input */
+    endMax?: number;
+    /** Custom message for start min validation */
+    startMinMessage?: string;
+    /** Custom message for start max validation */
+    startMaxMessage?: string;
+    /** Custom message for end min validation */
+    endMinMessage?: string;
+    /** Custom message for end max validation */
+    endMaxMessage?: string;
+    /**
+     * Offset mínimo do fim em relação ao início.
+     * Ex.: 10 => fim >= início + 10
+     */
+    endMinOffset?: number;
+    /**
+     * Offset máximo do início em relação ao fim.
+     * Ex.: 10 => início <= fim - 10
+     */
+    startMaxOffset?: number;
+    /** Custom message for endMinOffset validation */
+    endMinOffsetMessage?: string;
+    /** Custom message for startMaxOffset validation */
+    startMaxOffsetMessage?: string;
     /** Step increment for number controls */
     step?: number;
     /** Number formatting options */
@@ -3741,6 +4555,18 @@ interface MaterialSelectMetadata extends FieldMetadata {
     selectAll?: boolean;
     /** Maximum number of selections (for multiple) */
     maxSelections?: number;
+    /** Inline/runtime compatibility for panel search icon. */
+    panelSearchIcon?: string;
+    /** Inline/runtime compatibility for panel search icon color. */
+    panelSearchIconColor?: string;
+    /** Inline/runtime compatibility for panel reset icon. */
+    panelResetIcon?: string;
+    /** Inline/runtime compatibility for panel reset icon color. */
+    panelResetIconColor?: string;
+    /** Inline/runtime compatibility for selected option icon. */
+    optionSelectedIcon?: string;
+    /** Inline/runtime compatibility for selected option icon color. */
+    optionSelectedIconColor?: string;
 }
 /**
  * Metadata for Material Autocomplete components.
@@ -3990,6 +4816,57 @@ interface MaterialDateRangeMetadata extends FieldMetadata {
     endAriaLabel?: string;
     /** Start view (month, year, multi-year) */
     startView?: 'month' | 'year' | 'multi-year';
+    /** Enable sidebar shortcuts overlay (phase 1). */
+    showShortcuts?: boolean;
+    /**
+     * Shortcuts configuration. Accepts built-in identifiers or custom presets.
+     * Example: ['thisMonth', 'lastMonth', { id: 'last7', label: 'Últimos 7 dias', calculateRange: fn }]
+     */
+    shortcuts?: (string | DateRangePreset)[];
+    /**
+     * Inline quick presets for compact filters (`filter-date-range-inline`).
+     * - `true`: enabled with defaults
+     * - `false`: disabled
+     * - object: fine-grained control
+     */
+    inlineQuickPresets?: boolean | {
+        enabled?: boolean;
+        maxVisible?: number;
+    };
+    /** Accessibility label for the inline quick presets group. */
+    inlineQuickPresetsAriaLabel?: string;
+    /** Action label shown in the overlay footer for cancel. */
+    inlineQuickPresetsCancelLabel?: string;
+    /** Accessibility label for the cancel action in overlay footer. */
+    inlineQuickPresetsCancelAriaLabel?: string;
+    /** Action label shown in the overlay footer for apply. */
+    inlineQuickPresetsApplyLabel?: string;
+    /** Accessibility label for the apply action in overlay footer. */
+    inlineQuickPresetsApplyAriaLabel?: string;
+    /**
+     * Apply behavior for inline quick presets:
+     * - `auto`: applies immediately and closes the overlay
+     * - `confirm`: keeps selection as draft and only commits on explicit confirmation
+     */
+    inlineQuickPresetsApplyMode?: 'auto' | 'confirm';
+    /** Position of shortcuts sidebar relative to the form field. */
+    shortcutsPosition?: 'left' | 'right';
+    /** Apply immediately when clicking a shortcut. Defaults to true. */
+    applyOnShortcutClick?: boolean;
+    /** Timezone identifier (e.g., 'America/Sao_Paulo') for normalization. */
+    timezone?: string;
+    /** First day of week override; otherwise use DateAdapter.getFirstDayOfWeek(). */
+    startOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * Localized labels for built-in shortcuts.
+     * Keys: today, yesterday, thisWeek, lastWeek, thisMonth, lastMonth, thisYear, lastYear
+     */
+    i18nShortcuts?: Partial<Record<'today' | 'yesterday' | 'thisWeek' | 'lastWeek' | 'thisMonth' | 'lastMonth' | 'thisYear' | 'lastYear', string>>;
+    /**
+     * Now provider for deterministic testing and reporting alignment.
+     * Defaults to () => new Date().
+     */
+    nowProvider?: () => Date;
 }
 /**
  * Metadata for a price range input using two currency fields.
@@ -4024,10 +4901,104 @@ interface MaterialPriceRangeMetadata extends FieldMetadata {
     startLabel?: string;
     /** Label for end input */
     endLabel?: string;
+    /** Hide labels for start/end sub-inputs (compact mode). */
+    hideSubLabels?: boolean;
+    /** Layout dos inputs (lado a lado ou em linhas). */
+    layout?: 'row' | 'column';
+    /** Espaçamento entre os inputs (px ou CSS). */
+    gap?: number | string;
+    /** Onde exibir o botão clear: no grupo ou em cada subinput. */
+    clearButtonPlacement?: 'group' | 'subinputs';
+    /**
+     * Configuração do botão de limpar a faixa.
+     * Aceita boolean para compatibilidade ou objeto detalhado.
+     */
+    clearButton?: boolean | {
+        enabled: boolean;
+        icon?: string;
+        iconColor?: string;
+        tooltip?: string;
+        ariaLabel?: string;
+        showOnlyWhenFilled?: boolean;
+    };
+    /**
+     * Optional mini histogram/bars rendered above the inline range slider track.
+     * Accepts array shorthand, object config, or JSON string for editor compatibility.
+     */
+    inlineDistribution?: InlineRangeDistributionConfig | Array<number | InlineRangeDistributionBin> | string;
+    /**
+     * Alias accepted by inline range components for legacy payloads.
+     */
+    distribution?: InlineRangeDistributionConfig | Array<number | InlineRangeDistributionBin> | string;
 }
 /**
  * Metadata for the generic numeric range slider component.
  */
+interface InlineRangeDistributionBin {
+    /** Optional unique identifier */
+    id?: string;
+    /** Primary numeric amount for the bin */
+    value?: number;
+    /** Alias for `value` used by analytics payloads */
+    count?: number;
+    /** Alias for `value` used by finance payloads */
+    amount?: number;
+    /** Optional custom bar color */
+    color?: string;
+    /** Optional label for accessibility/reporting */
+    label?: string;
+}
+interface InlineRangeDistributionConfig {
+    /**
+     * Histogram bins as numeric shorthand or rich objects.
+     * Accepts array or JSON string for editor compatibility.
+     */
+    bins?: Array<number | InlineRangeDistributionBin> | string;
+    /** Optional normalization ceiling; defaults to the highest bin value. */
+    maxValue?: number;
+    /** Optional minimum visible ratio in the [0..1] range for non-zero bars. */
+    minBarRatio?: number;
+    /** Alias for `minBarRatio`. */
+    minVisibleRatio?: number;
+    /** Optional container height in px. */
+    height?: number;
+    /** Optional gap between bars in px. */
+    gap?: number;
+    /** Optional top border radius for bars in px. */
+    radius?: number;
+    /** Optional global opacity multiplier in the [0..1] range. */
+    opacity?: number;
+    /** Optional accessibility label for the bars group. */
+    ariaLabel?: string;
+}
+interface RangeSliderQuickPreset {
+    /** Optional unique identifier */
+    id?: string;
+    /** Label shown in the inline preset chip/button */
+    label: string;
+    /** Optional icon (Material icon name) */
+    icon?: string;
+    /** Preset for single mode */
+    value?: number | null;
+    /** Preset start for range mode */
+    start?: number | null;
+    /** Preset end for range mode */
+    end?: number | null;
+}
+interface RangeSliderInlineTexts {
+    minLabel?: string;
+    maxLabel?: string;
+    valueLabel?: string;
+    quickPresetsLabel?: string;
+}
+interface RangeSliderQuickPresetLabels {
+    low?: string;
+    middle?: string;
+    high?: string;
+    uptoMid?: string;
+    fromMid?: string;
+    full?: string;
+}
 interface MaterialRangeSliderMetadata extends FieldMetadata {
     controlType: typeof FieldControlType.RANGE_SLIDER;
     /** Slider mode */
@@ -4056,6 +5027,64 @@ interface MaterialRangeSliderMetadata extends FieldMetadata {
     displayWith?: (value: number) => string;
     /** Show numeric input boxes */
     showInputs?: boolean;
+    /**
+     * Optional mini histogram/bars rendered above the inline slider track.
+     * Accepts array shorthand, object config, or JSON string for editor compatibility.
+     */
+    inlineDistribution?: InlineRangeDistributionConfig | Array<number | InlineRangeDistributionBin> | string;
+    /**
+     * Alias accepted by inline range components for legacy payloads.
+     */
+    distribution?: InlineRangeDistributionConfig | Array<number | InlineRangeDistributionBin> | string;
+    /**
+     * Quick presets shown in compact inline variant.
+     * Accepts a typed array or JSON string for editor/backward compatibility.
+     */
+    quickPresets?: RangeSliderQuickPreset[] | string;
+    /** Enables auto-generated quick presets when `quickPresets` is not provided. */
+    quickPresetsAuto?: boolean;
+    /**
+     * Optional labels for auto-generated presets.
+     * Accepts object or JSON string for editor/backward compatibility.
+     */
+    quickPresetsLabels?: RangeSliderQuickPresetLabels | string;
+    /**
+     * Compact inline textual labels (inputs and quick presets group).
+     * Accepts object or JSON string for editor/backward compatibility.
+     */
+    inlineTexts?: RangeSliderInlineTexts | string;
+    /**
+     * Enables half-step interactions for inline rating ranges.
+     * When `true`, the rating range defaults to step `0.5` unless an explicit step is set.
+     */
+    allowHalf?: boolean;
+    /**
+     * Legacy alias for `allowHalf` used by some integrations.
+     */
+    ratingAllowHalf?: boolean;
+    /**
+     * Optional precision hint for rating-range interpretation (`0.5` enables half-step).
+     */
+    ratingPrecision?: number;
+    /**
+     * Optional precision token for rating-range interpretation (`half` enables half-step).
+     */
+    precision?: string | number;
+    /**
+     * Optional aliases consumed by inline rating implementations.
+     * `ratingMin` and `ratingMax` are fallbacks when `min`/`max` are omitted.
+     */
+    ratingMin?: number;
+    ratingMax?: number;
+    ratingStep?: number;
+    itemsCount?: number;
+    /**
+     * Optional visual customization for inline rating tone colors.
+     */
+    ratingToneLowColor?: string;
+    ratingToneMidColor?: string;
+    ratingToneHighColor?: string;
+    ratingBadgeColor?: string;
     /** Custom validator messages */
     validators?: FieldMetadata['validators'] & {
         minMessage?: string;
@@ -4197,6 +5226,18 @@ interface MaterialColorPickerMetadata extends FieldMetadata {
     showInput?: boolean;
     /** Show color preview */
     showPreview?: boolean;
+    /**
+     * Configuração do botão de limpar no painel do color picker.
+     * Aceita boolean para compatibilidade ou objeto detalhado.
+     */
+    clearButton?: boolean | {
+        enabled: boolean;
+        icon?: string;
+        iconColor?: string;
+        tooltip?: string;
+        ariaLabel?: string;
+        showOnlyWhenFilled?: boolean;
+    };
 }
 /**
  * Specialized metadata for Material Currency Input components.
@@ -4324,6 +5365,19 @@ interface MaterialPhoneMetadata extends BaseMaterialInputMetadata {
 interface MaterialPasswordMetadata extends BaseMaterialInputMetadata {
     controlType: typeof FieldControlType.PASSWORD;
     inputType: 'password';
+    /**
+     * Optional reveal toggle (show/hide password).
+     * Use style: 'icon' for eye icon, 'text' for a small text button.
+     */
+    revealToggle?: {
+        enabled?: boolean;
+        style?: 'icon' | 'text';
+        showLabel?: string;
+        hideLabel?: string;
+        iconShow?: string;
+        iconHide?: string;
+        ariaLabel?: string;
+    };
 }
 /**
  * Metadata for Material URL Input components.
@@ -4434,6 +5488,22 @@ interface MaterialTimeInputMetadata extends BaseMaterialInputMetadata {
     max?: string;
     /** Step for minute increments in seconds. */
     step?: number;
+    /** Inline/runtime compatibility for compact filter variant. */
+    interval?: number | string;
+    /** Inline/runtime compatibility for compact filter variant. */
+    timeOptions?: string[];
+    /** Inline/runtime compatibility for compact filter variant. */
+    showSeconds?: boolean;
+    /** Inline/runtime compatibility for compact filter variant. */
+    stepMinute?: number;
+    /** Inline/runtime compatibility for compact filter variant. */
+    stepSecond?: number;
+    /** Inline/runtime compatibility for compact filter variant. */
+    inlineTimeMode?: 'auto' | 'list' | 'columns';
+    /** Inline/runtime compatibility for compact filter variant. */
+    inlineListMaxOptions?: number;
+    /** Inline/runtime compatibility for compact filter variant. */
+    inlineTexts?: MaterialTimepickerMetadata['inlineTexts'];
 }
 /**
  * Metadata for Material Timepicker components.
@@ -4450,7 +5520,7 @@ interface MaterialTimepickerMetadata extends BaseMaterialInputMetadata {
     /**
      * Interval between options in the timepicker.
      * Can be a number of seconds or a string with units like '30m'.
-     * Ignored if `options` is provided.
+     * Ignored if `timeOptions` is provided.
      */
     interval?: number | string;
     /** Specific selectable time options. Takes precedence over `interval`. */
@@ -4467,6 +5537,39 @@ interface MaterialTimepickerMetadata extends BaseMaterialInputMetadata {
     stepMinute?: number;
     /** Second increment when entering time manually. */
     stepSecond?: number;
+    /**
+     * Rendering mode for inline filter variant:
+     * - `list`: single list of options
+     * - `columns`: independent columns for hour/minute(/second)
+     * - `auto`: chooses best mode based on metadata/options
+     */
+    inlineTimeMode?: 'auto' | 'list' | 'columns';
+    /**
+     * Max options threshold for `inlineTimeMode: 'auto'` to still prefer list.
+     * Values outside range are clamped by the component.
+     */
+    inlineListMaxOptions?: number;
+    /**
+     * Text overrides for inline time variant.
+     */
+    inlineTexts?: {
+        hourLabel?: string;
+        minuteLabel?: string;
+        secondLabel?: string;
+        emptyStateLabel?: string;
+        openPanelAriaLabel?: string;
+        closePanelAriaLabel?: string;
+    };
+    /** Inline/runtime compatibility for panel toggle icon when closed. */
+    panelToggleCloseIcon?: string;
+    /** Inline/runtime compatibility for panel toggle icon when open. */
+    panelToggleOpenIcon?: string;
+    /** Inline/runtime compatibility for panel toggle icon color. */
+    panelToggleIconColor?: string;
+    /** Inline/runtime compatibility for selected option icon. */
+    optionSelectedIcon?: string;
+    /** Inline/runtime compatibility for selected option icon color. */
+    optionSelectedIconColor?: string;
     /** Identifier of a custom filter function to disable specific times. */
     timeFilter?: string;
 }
@@ -4504,6 +5607,28 @@ interface MaterialTreeSelectMetadata extends FieldMetadata {
     controlType: typeof FieldControlType.TREE_SELECT;
     /** Tree nodes to display */
     nodes?: MaterialTreeNode[];
+    /** Enable search input */
+    searchable?: boolean;
+    /** Placeholder text for tree search input */
+    searchPlaceholder?: string;
+    /** Empty state message for filtered tree */
+    emptyStateText?: string;
+    /** Inline/runtime compatibility for panel search icon. */
+    panelSearchIcon?: string;
+    /** Inline/runtime compatibility for panel search icon color. */
+    panelSearchIconColor?: string;
+    /** Inline/runtime compatibility for panel toggle icon when closed. */
+    panelToggleCloseIcon?: string;
+    /** Inline/runtime compatibility for panel toggle icon when open. */
+    panelToggleOpenIcon?: string;
+    /** Inline/runtime compatibility for panel toggle icon color. */
+    panelToggleIconColor?: string;
+    /** Inline/runtime compatibility for expanded tree node icon. */
+    treeNodeExpandedIcon?: string;
+    /** Inline/runtime compatibility for collapsed tree node icon. */
+    treeNodeCollapsedIcon?: string;
+    /** Inline/runtime compatibility for tree node toggle icon color. */
+    treeNodeIconColor?: string;
     /** Whether only leaf nodes can be selected */
     leafOnly?: boolean;
     /** Auto expand matches when searching */
@@ -4556,7 +5681,7 @@ declare function buildValidatorsFromValidatorOptions(opts?: ValidatorOptions): B
  * - Injetar validadores específicos de UI conforme o controlType:
  *   - DATE_PICKER: minDate/maxDate (datas limites).
  *   - DATE_RANGE: verificação de ordem (start <= end) e min/max date.
- *   - RANGE_SLIDER: verificação de ordem e min/max numérico.
+ *   - RANGE_SLIDER/PRICE_RANGE: verificação de ordem e min/max numérico.
  * - Tratar campos múltiplos (checkbox/multi-select): valor inicial [] quando não informado.
  * - Reconfigurar controles existentes (validators, asyncValidators, enabled/disabled, defaultValue).
  *
@@ -4712,6 +5837,10 @@ declare class ErrorMessageService {
 interface ComponentDocMeta {
     /** Unique identifier used by the registry */
     id: string;
+    /** Canonical component type for AI registry (ex: praxis-table) */
+    componentType?: string;
+    /** Display name used by AI docs/catalogs */
+    displayName?: string;
     /** Angular component selector */
     selector: string;
     /** Component class reference */
@@ -4739,6 +5868,50 @@ interface ComponentDocMeta {
         /** Optional friendly label for UI (diagram/builders) */
         label?: string;
     }>;
+    /** Optional reusable actions catalog (shell/toolbar/context/etc). */
+    actions?: Array<{
+        id: string;
+        label: string;
+        /** Optional icon name for UI suggestions. */
+        icon?: string;
+        description?: string;
+        /** Optional command name to dispatch to the component. */
+        command?: string;
+        /** Optional output name to emit by default. */
+        emit?: string;
+        /** Optional payload schema for validation/UI. */
+        payloadSchema?: {
+            type: 'object' | 'string' | 'number' | 'boolean' | 'array';
+            properties?: Record<string, {
+                type: string;
+                description?: string;
+                required?: boolean;
+            }>;
+            required?: string[];
+            example?: any;
+        };
+        /** Optional scope hint for UI placement. */
+        scope?: 'shell' | 'toolbar' | 'context' | 'any';
+    }>;
+    /** Optional commands catalog for advanced actions. */
+    commands?: Array<{
+        name: string;
+        label: string;
+        /** Optional icon name for UI suggestions. */
+        icon?: string;
+        description?: string;
+        /** Optional payload schema for validation/UI. */
+        payloadSchema?: {
+            type: 'object' | 'string' | 'number' | 'boolean' | 'array';
+            properties?: Record<string, {
+                type: string;
+                description?: string;
+                required?: boolean;
+            }>;
+            required?: string[];
+            example?: any;
+        };
+    }>;
     /** Tags or categories for search */
     tags?: string[];
     /** Source library for the component */
@@ -4762,360 +5935,569 @@ interface ComponentDocMeta {
  */
 declare class ComponentMetadataRegistry {
     private readonly metadataMap;
+    private readonly componentTypeAliases;
     /** Register a component metadata entry. */
     register(meta: ComponentDocMeta): void;
     /** Retrieve metadata by its unique id. */
-    get(id: string): ComponentDocMeta | undefined;
-    /** List all registered metadata entries. */
-    getAll(): ComponentDocMeta[];
-    /**
-     * Ensure friendly labels/descriptions for common inputs/outputs when missing.
-     * This helps diagrams/builders present consistent naming across components.
-     */
-    private normalizeMeta;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentMetadataRegistry, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentMetadataRegistry>;
-}
-
-interface TelemetryEvent {
-    name: string;
-    payload?: any;
-    timestamp: string;
-}
-declare class TelemetryService {
-    record(name: string, payload?: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TelemetryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TelemetryService>;
-}
-
-interface Specification<T extends object = any> {
-    isSatisfiedBy(obj: T): boolean;
-}
-
-interface FormActionButton {
-    id?: string;
-    visible: boolean;
-    label: string;
-    icon?: string;
-    color?: 'primary' | 'accent' | 'warn' | 'basic';
-    disabled?: boolean;
-    type?: 'button' | 'submit' | 'reset';
-    action?: string;
-    tooltip?: string;
-    loading?: boolean;
-    size?: 'small' | 'medium' | 'large';
-    variant?: 'raised' | 'stroked' | 'flat' | 'fab';
-    shortcut?: string;
-}
-interface FormActionsLayout {
-    /**
-     * Configuration for the submit button
-     */
-    submit: FormActionButton;
-    /**
-     * Configuration for the cancel button
-     */
-    cancel: FormActionButton;
-    /**
-     * Configuration for the reset button
-     */
-    reset: FormActionButton;
-    /**
-     * Custom buttons
-     */
-    custom?: FormActionButton[];
-    /**
-     * Layout and behavior
-     */
-    position?: 'left' | 'center' | 'right' | 'justified' | 'split';
-    orientation?: 'horizontal' | 'vertical';
-    spacing?: 'compact' | 'normal' | 'spacious';
-    sticky?: boolean;
-    /**
-     * Structural placement of the actions bar within the form layout.
-     * - insideLastSection: render inside the last section's container (default)
-     * - afterSections: render once after all sections
-     * - top: render once before all sections
-     */
-    placement?: 'insideLastSection' | 'afterSections' | 'top';
-    /**
-     * Responsive settings
-     */
-    mobile?: {
-        position?: 'left' | 'center' | 'right' | 'justified';
-        orientation?: 'horizontal' | 'vertical';
-        collapseToMenu?: boolean;
-    };
-    containerClassName?: string;
-    containerStyles?: {
-        [key: string]: any;
-    };
-    showSaveButton?: boolean;
-    submitButtonLabel?: string;
-    showCancelButton?: boolean;
-    cancelButtonLabel?: string;
-    showResetButton?: boolean;
-    resetButtonLabel?: string;
-}
-interface FormApiLayout {
-    saveEndpoint?: string;
-    loadEndpoint?: string;
-    saveMethod?: 'POST' | 'PUT' | 'PATCH';
-    timeout?: number;
-    headers?: Record<string, string>;
-    idField?: string;
-    beforeSave?: string;
-    afterLoad?: string;
-}
-interface FormBehaviorLayout {
-    confirmOnUnsavedChanges?: boolean;
-    trackHistory?: boolean;
-    focusFirstError?: boolean;
-    scrollToErrors?: boolean;
-    clearAfterSave?: boolean;
-    redirectAfterSave?: string;
+    get(id: string): ComponentDocMeta | undefined;
+    /** List all registered metadata entries. */
+    getAll(): ComponentDocMeta[];
     /**
-     * Enables afterValidate hooks to run reactively on form.valueChanges.
-     * Default is false.
+     * Ensure friendly labels/descriptions for common inputs/outputs when missing.
+     * This helps diagrams/builders present consistent naming across components.
      */
-    reactiveValidation?: boolean;
-    /** Debounce for reactive afterValidate hooks (ms). Default 150ms. */
-    reactiveValidationDebounceMs?: number;
+    private normalizeMeta;
+    private normalizeComponentType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentMetadataRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentMetadataRegistry>;
 }
-interface FormMetadataLayout {
-    formCode?: string;
-    version?: string;
-    [key: string]: any;
+
+type ComponentKeyParams = {
+    componentType: string;
+    componentId?: string | null;
+    resourcePath?: string | null;
+    instanceKey?: string | null;
+    componentRef?: object;
+    route?: ActivatedRoute | null;
+    requireComponentId?: boolean;
+    useResourcePathFallback?: boolean;
+};
+declare class ComponentKeyService {
+    private readonly router;
+    buildComponentId(params: ComponentKeyParams): string | null;
+    private resolveRouteKey;
+    private resolveRouteOverride;
+    private buildRoutePath;
+    private normalizeRouteKey;
+    private stripQueryAndFragment;
+    private normalizeResourcePath;
+    private sanitizeSegment;
+    private buildScopeKey;
+    private resolveInstanceKey;
+    private hashIfNeeded;
+    private shortSegment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentKeyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentKeyService>;
 }
-interface FormMessagesLayout {
-    updateRegistrySuccess?: string;
-    createRegistrySuccess?: string;
-    updateRegistryError?: string;
-    createRegistryError?: string;
-    confirmations?: {
-        submit?: string;
-        cancel?: string;
-        reset?: string;
-        [customAction: string]: string | undefined;
-    };
-    customActions?: {
-        [actionId: string]: {
-            success?: string;
-            error?: string;
-            confirmation?: string;
-        };
-    };
-    loading?: {
-        submit?: string;
-        cancel?: string;
-        reset?: string;
-        [customAction: string]: string | undefined;
-    };
-    [key: string]: any;
+
+interface TelemetryEvent {
+    name: string;
+    payload?: unknown;
+    timestamp: string;
 }
-interface FormRowLayout {
-    id: string;
-    name?: string;
+interface TelemetryTransport {
+    emit(event: TelemetryEvent): void;
+}
+declare const PRAXIS_TELEMETRY_TRANSPORT: InjectionToken<TelemetryTransport>;
+declare class TelemetryService {
+    private readonly transport;
+    private readonly eventsSubject;
+    readonly events$: Observable<TelemetryEvent>;
+    record(name: string, payload?: unknown): void;
+    emit(event: TelemetryEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TelemetryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TelemetryService>;
+}
+
+type FieldSelectorRegistryMap = Record<string, FieldControlType>;
+declare const FIELD_SELECTOR_REGISTRY_BASE: InjectionToken<FieldSelectorRegistryMap>;
+declare const FIELD_SELECTOR_REGISTRY_OVERRIDES: InjectionToken<FieldSelectorRegistryMap[]>;
+declare const FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS: InjectionToken<boolean>;
+declare function provideFieldSelectorRegistryBase(map: FieldSelectorRegistryMap): Provider;
+declare function provideFieldSelectorRegistryOverride(map: FieldSelectorRegistryMap): Provider;
+
+declare class FieldSelectorRegistry {
+    private readonly baseMap;
+    private readonly overrideMaps;
+    private readonly registry;
+    constructor();
+    register(map: FieldSelectorRegistryMap, opts?: {
+        overwrite?: boolean;
+    }): void;
+    resolve(selector: string | undefined | null): FieldControlType | undefined;
+    getAll(): FieldSelectorRegistryMap;
+    private applyMap;
+    private normalizeSelector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldSelectorRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldSelectorRegistry>;
+}
+
+type LoadingPhase$1 = 'schema' | 'mount' | 'data' | 'action';
+interface LoadingScope {
+    componentType: string;
+    componentId: string;
+    routeKey?: string;
+}
+interface LoadingContext {
+    scope: LoadingScope;
+    phase: LoadingPhase$1;
     label?: string;
-    orientation: 'horizontal' | 'vertical';
-    fields: FieldMetadata[];
-    styles?: {
-        [key: string]: any;
-    };
-    hiddenCondition?: string | Specification<any> | null;
-    visibilityCondition?: string | Specification<any> | null;
+    blocking?: boolean;
+    priority?: 'low' | 'normal' | 'high';
 }
-interface NestedFieldsetLayout extends FormRowLayout {
-    fieldsets?: FieldsetLayout[];
+
+declare class LoadingOrchestrator {
+    private readonly counters;
+    private readonly state$;
+    begin(ctx: LoadingContext): string;
+    end(ctx: LoadingContext): void;
+    watch(): Observable<LoadingContext[]>;
+    private keyOf;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingOrchestrator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingOrchestrator>;
 }
-interface FieldsetLayout {
-    id: string;
-    title: string;
-    titleNew?: string;
-    titleView?: string;
-    titleEdit?: string;
-    orientation: 'horizontal' | 'vertical';
-    rows: FormRowLayout[];
-    hiddenCondition?: string | Specification<any> | null;
+
+interface PraxisLoadingRenderer {
+    show(ctx: LoadingContext): void;
+    update?(ctx: LoadingContext): void;
+    hide(ctx: LoadingContext): void;
 }
-type FormRuleContext = 'visibility' | 'readOnly' | 'style' | 'validation' | 'notification';
-interface FormLayoutRule {
-    id: string;
+declare const PRAXIS_LOADING_RENDERER: InjectionToken<PraxisLoadingRenderer>;
+
+declare class PraxisLoadingInterceptor implements HttpInterceptor {
+    private orchestrator;
+    private renderer?;
+    constructor(orchestrator: LoadingOrchestrator, renderer?: PraxisLoadingRenderer | undefined);
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisLoadingInterceptor, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PraxisLoadingInterceptor>;
+}
+
+declare class DefaultLoadingRenderer implements PraxisLoadingRenderer {
+    private readonly rootId;
+    private readonly styleId;
+    show(ctx: LoadingContext): void;
+    update(ctx: LoadingContext): void;
+    hide(ctx: LoadingContext): void;
+    private keyOf;
+    private defaultLabel;
+    private ensureRoot;
+    private ensureStyles;
+    private getDocument;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLoadingRenderer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultLoadingRenderer>;
+}
+
+declare function provideFieldSelectorRegistryRuntime(map: FieldSelectorRegistryMap, opts?: {
+    overwrite?: boolean;
+}): Provider;
+
+type PraxisToastOptions = {
+    successDurationMs?: number;
+    errorDurationMs?: number;
+    successPanelClass?: string | string[];
+    errorPanelClass?: string | string[];
+};
+declare function providePraxisToastGlobalActions(opts?: PraxisToastOptions): Provider;
+
+type PraxisAnalyticsOptions = {
+    prefix?: string;
+};
+declare function providePraxisAnalyticsGlobalActions(opts?: PraxisAnalyticsOptions): Provider;
+
+declare function providePraxisLoadingDefaults(): Provider[];
+
+type LoggerLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+type PraxisLoggingEnvironment = 'prod' | 'qa' | 'hml' | 'dev';
+interface LoggerContext {
+    lib?: string;
+    component?: string;
+    actionId?: string;
+    correlationId?: string;
+    feature?: string;
+    [key: string]: unknown;
+}
+interface LoggerEvent {
+    level: LoggerLevel;
+    message: string;
+    timestamp: string;
+    environment: PraxisLoggingEnvironment;
+    context?: LoggerContext;
+    data?: unknown;
+}
+interface LoggerThrottleConfig {
+    enabled: boolean;
+    windowMs: number;
+    maxOccurrences: number;
+}
+interface LoggerPIIConfig {
+    enabled: boolean;
+    sensitiveKeys: string[];
+    redactionText: string;
+}
+interface LoggerConfig {
+    environment: PraxisLoggingEnvironment;
+    minLevel: LoggerLevel;
+    warnOnceEnabled: boolean;
+    throttle: LoggerThrottleConfig;
+    pii: LoggerPIIConfig;
+    defaultContext?: LoggerContext;
+}
+interface LoggerLogOptions {
+    context?: LoggerContext;
+    data?: unknown;
+    dedupeKey?: string;
+    throttleKey?: string;
+    skipThrottle?: boolean;
+}
+interface LoggerSink {
+    log(event: LoggerEvent): void;
+}
+interface LoggerNormalizedError {
     name: string;
-    context: FormRuleContext;
-    targetFields: string[];
-    description?: string;
-    effect: {
-        condition: string | Specification<any> | null;
-        styleClass?: string;
-        style?: {
-            [key: string]: any;
-        };
-        /** Optional validation overrides to apply when condition is satisfied */
-        validatorOverrides?: Partial<ValidatorOptions>;
-    };
+    message: string;
+    stack?: string;
 }
-interface FormLayout {
-    formTitle?: string;
-    formDescription?: string;
-    formTitleCreate?: string;
-    formDescriptionCreate?: string;
-    formTitleView?: string;
-    formDescriptionView?: string;
-    formTitleEdit?: string;
-    formDescriptionEdit?: string;
-    className?: string;
-    styles?: {
-        [key: string]: any;
+interface LoggerTelemetryPayload {
+    timestamp: string;
+    level: LoggerLevel;
+    message: string;
+    environment: PraxisLoggingEnvironment;
+    context: {
+        lib: string;
+        component: string;
+        actionId?: string;
+        correlationId?: string;
     };
-    actions?: FormActionsLayout;
-    api?: FormApiLayout;
-    behavior?: FormBehaviorLayout;
-    metadata?: FormMetadataLayout;
-    messages?: FormMessagesLayout;
-    fieldsets: FieldsetLayout[];
-    formRules?: FormLayoutRule[];
+    error?: LoggerNormalizedError;
+    data?: unknown;
+}
+interface PraxisLoggingOptions {
+    environment?: PraxisLoggingEnvironment;
+    minLevel?: LoggerLevel;
+    warnOnceEnabled?: boolean;
+    throttle?: Partial<LoggerThrottleConfig>;
+    pii?: Partial<LoggerPIIConfig>;
+    defaultContext?: LoggerContext;
+    enableConsoleSink?: boolean;
+    enableTelemetrySink?: boolean;
+    telemetryEventName?: string;
+    enableGlobalErrorHandler?: boolean;
+    sinks?: ReadonlyArray<LoggerSink>;
 }
 
-interface FormValueChangeEvent {
-    formData: any;
-    changedField?: string;
-    previousValue?: any;
-    currentValue?: any;
-    changedFields: string[];
-    isValid: boolean;
-    entityId?: string | number;
+declare const LOGGER_LEVEL_PRIORITY: Record<LoggerLevel, number>;
+declare const LOGGER_LEVEL_BY_ENV: Record<PraxisLoggingEnvironment, LoggerLevel>;
+declare const PRAXIS_CORPORATE_SENSITIVE_KEYS: string[];
+declare function createCorporateLoggerConfig(environment?: PraxisLoggingEnvironment): LoggerConfig;
+declare function resolveLoggerConfig(options?: PraxisLoggingOptions): LoggerConfig;
+
+declare const PRAXIS_LOGGER_CONFIG: InjectionToken<LoggerConfig>;
+declare const PRAXIS_LOGGER_SINKS: InjectionToken<readonly LoggerSink[]>;
+
+declare class LoggerService {
+    private readonly config;
+    private readonly sinks;
+    private readonly warnOnceTracker;
+    private readonly throttleTracker;
+    private readonly sensitiveKeys;
+    constructor(config: LoggerConfig, sinks: ReadonlyArray<LoggerSink>);
+    error(message: string, options?: LoggerLogOptions): void;
+    warn(message: string, options?: LoggerLogOptions): void;
+    info(message: string, options?: LoggerLogOptions): void;
+    debug(message: string, options?: LoggerLogOptions): void;
+    trace(message: string, options?: LoggerLogOptions): void;
+    warnOnce(message: string, options?: LoggerLogOptions): void;
+    log(level: LoggerLevel, message: string, options?: LoggerLogOptions): void;
+    private isLevelEnabled;
+    private shouldEmitByThrottle;
+    private composeKey;
+    private buildContext;
+    private sanitizeContext;
+    private sanitizeData;
+    private sanitizeValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
 }
-interface ValidationError {
-    field: string;
-    type: 'required' | 'pattern' | 'min' | 'max' | 'email' | 'custom';
+
+declare class PraxisGlobalErrorHandler implements ErrorHandler {
+    private readonly logger;
+    private handlingError;
+    constructor(logger: LoggerService);
+    handleError(error: unknown): void;
+    private safeFallback;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisGlobalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PraxisGlobalErrorHandler>;
+}
+
+declare function providePraxisLogging(options?: PraxisLoggingOptions): Provider[];
+
+interface NormalizedError {
+    name: string;
     message: string;
-    currentValue?: any;
-    expectedValue?: any;
+    stack?: string;
 }
-interface FormSubmitEvent {
-    stage: 'before' | 'after' | 'error';
-    formData: any;
-    isValid: boolean;
-    validationErrors?: ValidationError[];
-    entityId?: string | number;
-    operation: 'create' | 'update';
-    result?: any;
-    error?: any;
+declare function normalizeUnknownError(rawError: unknown): NormalizedError;
+declare function extractNormalizedError(data: unknown): NormalizedError | undefined;
+
+declare class LoggerWarnOnceTracker {
+    private readonly emittedKeys;
+    shouldEmit(key: string): boolean;
+    clear(): void;
 }
-interface FormValidationEvent {
-    isValid: boolean;
-    errors: {
-        [fieldName: string]: ValidationError[];
+
+declare class LoggerThrottleTracker {
+    private readonly config;
+    private readonly windows;
+    constructor(config: LoggerThrottleConfig);
+    shouldEmit(key: string, now?: number): boolean;
+    clear(): void;
+}
+
+type ObservabilityAlertSeverity = 'warn' | 'error' | 'critical';
+type ObservabilityAlertGroupBy = 'global' | 'lib' | 'component' | 'actionId';
+interface ObservabilityAlertRule {
+    id: string;
+    name: string;
+    severity: ObservabilityAlertSeverity;
+    level: LoggerLevel;
+    threshold: number;
+    windowMs: number;
+    groupBy: ObservabilityAlertGroupBy;
+    throttleMs?: number;
+}
+interface ObservabilityCountBucket {
+    key: string;
+    count: number;
+}
+interface ObservabilityMetricsSnapshot {
+    generatedAt: string;
+    windowMs: number;
+    totalEvents: number;
+    bySeverity: Record<LoggerLevel, number>;
+    byLib: ReadonlyArray<ObservabilityCountBucket>;
+    byComponent: ReadonlyArray<ObservabilityCountBucket>;
+    topActionIds: ReadonlyArray<ObservabilityCountBucket>;
+}
+interface ObservabilityAlert {
+    severity: ObservabilityAlertSeverity;
+    rule: {
+        id: string;
+        name: string;
+        level: LoggerLevel;
+        groupBy: ObservabilityAlertGroupBy;
+        threshold: number;
+        windowMs: number;
+    };
+    timestamp: string;
+    observedCount: number;
+    context: {
+        lib?: string;
+        component?: string;
+        actionId?: string;
+        correlationId?: string;
     };
-    validatedFields: string[];
-    invalidFields: string[];
-    formStatus: 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
 }
-interface FormEntityEvent {
-    operation: 'load' | 'create' | 'update' | 'delete';
-    entityId?: string | number;
-    entityData?: any;
-    success: boolean;
-    result?: any;
-    error?: any;
-    timestamp: Date;
+interface ObservabilityDashboardOptions {
+    enabled: boolean;
+    telemetryEventNames: ReadonlyArray<string>;
+    defaultWindowMs: number;
+    maxStoredEvents: number;
+    maxStoredAlerts: number;
+    topActionsLimit: number;
+    defaultAlertThrottleMs: number;
+    alertRules: ReadonlyArray<ObservabilityAlertRule>;
+    nowProvider?: () => number;
+}
+interface ObservabilityIngestInput {
+    payload: LoggerTelemetryPayload;
 }
-interface FormReadyEvent {
-    formGroup: FormGroup;
-    fieldsMetadata: FieldMetadata[];
-    layout?: FormLayout;
-    hasEntity: boolean;
-    entityId?: string | number;
+
+declare const PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES: ReadonlyArray<ObservabilityAlertRule>;
+declare function createCorporateObservabilityOptions(): ObservabilityDashboardOptions;
+declare function resolveObservabilityOptions(options?: Partial<ObservabilityDashboardOptions>): ObservabilityDashboardOptions;
+
+declare const PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS: InjectionToken<ObservabilityDashboardOptions>;
+
+declare class ObservabilityDashboardService {
+    private readonly options;
+    private readonly trackedEventNames;
+    private readonly retentionWindowMs;
+    private readonly recentAlerts;
+    private readonly alertThrottleMap;
+    private readonly records;
+    private readonly alertsSubject;
+    private readonly metricsSubject;
+    readonly alerts$: Observable<ObservabilityAlert>;
+    readonly metrics$: Observable<ObservabilityMetricsSnapshot>;
+    constructor(options: ObservabilityDashboardOptions, telemetryService: TelemetryService | null);
+    ingestPayload(payload: LoggerTelemetryPayload): void;
+    ingestTelemetryEvent(event: TelemetryEvent): void;
+    getSnapshot(windowMs?: number): ObservabilityMetricsSnapshot;
+    getRecentAlerts(limit?: number): ReadonlyArray<ObservabilityAlert>;
+    clear(): void;
+    private evaluateAlerts;
+    private buildAlertContext;
+    private groupRecordsByRule;
+    private trimRecords;
+    private buildSnapshot;
+    private incrementCounter;
+    private toSortedBuckets;
+    private normalizePayload;
+    private toLoggerTelemetryPayload;
+    private toTimestampMs;
+    private normalizeWindowMs;
+    private now;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObservabilityDashboardService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObservabilityDashboardService>;
 }
-interface FormInitializationError {
-    stage: 'config-load' | 'schema-fetch' | 'sync' | 'form-build';
-    error: Error;
-    context?: {
-        formId?: string;
-        resourcePath?: string;
-        hasLocalConfig?: boolean;
-    };
-    recoverable: boolean;
-    userMessage: string;
+
+declare class ConsoleLoggerSink implements LoggerSink {
+    log(event: LoggerEvent): void;
+    private resolveMethod;
 }
-interface FormCustomActionEvent {
-    actionId: string;
-    formData: any;
-    isValid: boolean;
-    source: 'button' | 'shortcut';
+
+interface TelemetryLoggerSinkOptions {
+    eventName?: string;
+    sensitiveKeys?: string[];
+    redactionText?: string;
+}
+declare class TelemetryLoggerSink implements LoggerSink {
+    private readonly telemetry;
+    private readonly options;
+    private readonly sensitiveKeys;
+    private readonly redactionText;
+    constructor(telemetry: TelemetryService, options?: TelemetryLoggerSinkOptions);
+    log(event: LoggerEvent): void;
+    private buildPayload;
+    private sanitizeValue;
+    private sanitizeText;
 }
-interface FormActionConfirmationEvent {
-    actionId: 'submit' | 'cancel' | 'reset' | string;
-    message: string;
-    confirmed: boolean;
+
+declare const OVERLAY_DECISION_MATRIX: InjectionToken<OverlayDecisionMatrix>;
+declare function provideOverlayDecisionMatrix(matrix?: OverlayDecisionMatrix): EnvironmentProviders;
+
+declare const GLOBAL_CONFIG: InjectionToken<Partial<GlobalConfig>>;
+interface PraxisAuthContext {
+    ready?: () => Promise<void>;
+    token?: () => string | undefined;
+    tenant?: () => string | undefined;
+    locale?: () => string | undefined;
+}
+interface PraxisGlobalConfigBootstrapOptions {
+    auth?: PraxisAuthContext;
+    remote?: {
+        baseUrl?: string;
+        apiPath?: string;
+    };
+    headers?: Record<string, string>;
+    headersFactory?: () => Record<string, string>;
+    includeDefaultHeaders?: boolean;
+    blocking?: 'auth+global' | 'global' | 'none';
+    errorPolicy?: 'fail' | 'ignore';
+    timeoutMs?: number;
+}
+declare const PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS: InjectionToken<PraxisGlobalConfigBootstrapOptions>;
+declare const PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY: InjectionToken<() => Promise<void>>;
+declare const PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER: InjectionToken<() => string | undefined>;
+declare function provideGlobalConfig(partial: Partial<GlobalConfig>): Provider;
+
+/** Set the current tenant for GlobalConfigService at app boot. */
+declare function provideGlobalConfigTenant(tenantId: string): Provider;
+/** Block app bootstrap until the global config is loaded for the active tenant. */
+declare function provideGlobalConfigReady(): Provider;
+/** Seed global config once when no storage exists yet (idempotent). */
+declare function provideGlobalConfigSeed(seed: Partial<GlobalConfig>): Provider;
+/** Fetch remote JSON and merge as global config at boot. */
+declare function provideRemoteGlobalConfig(url: string): Provider;
+declare function providePraxisGlobalConfigBootstrap(options?: PraxisGlobalConfigBootstrapOptions): Provider[];
+
+type PraxisGlobalActionsOptions = {
+    dialog?: boolean | GlobalDialogService;
+    toast?: boolean | GlobalToastService;
+    analytics?: boolean | GlobalAnalyticsService;
+    api?: boolean | GlobalApiClient;
+    guards?: boolean | GlobalRouteGuardResolver;
+};
+declare function providePraxisGlobalActions(opts?: PraxisGlobalActionsOptions): Provider[];
+
+declare const GLOBAL_ACTION_HANDLERS: InjectionToken<GlobalActionHandlerEntry[]>;
+declare const GLOBAL_DIALOG_SERVICE: InjectionToken<GlobalDialogService>;
+declare const GLOBAL_TOAST_SERVICE: InjectionToken<GlobalToastService>;
+declare const GLOBAL_ANALYTICS_SERVICE: InjectionToken<GlobalAnalyticsService>;
+declare const GLOBAL_API_CLIENT: InjectionToken<GlobalApiClient>;
+declare const GLOBAL_ROUTE_GUARD_RESOLVER: InjectionToken<GlobalRouteGuardResolver>;
+declare function provideGlobalActionHandler(entry: GlobalActionHandlerEntry): Provider;
+
+type GlobalActionCatalogEntry = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    payloadSchema?: {
+        type: 'object' | 'string' | 'number' | 'boolean' | 'array';
+        properties?: Record<string, {
+            type: string;
+            description?: string;
+            required?: boolean;
+        }>;
+        required?: string[];
+        example?: any;
+    };
+};
+declare const GLOBAL_ACTION_CATALOG$1: InjectionToken<readonly GlobalActionCatalogEntry[][]>;
+declare function provideGlobalActionCatalog(entries: GlobalActionCatalogEntry[]): Provider;
+declare function getGlobalActionCatalog(catalog: ReadonlyArray<GlobalActionCatalogEntry[]> | null | undefined): GlobalActionCatalogEntry[];
+declare const PRAXIS_GLOBAL_ACTION_CATALOG: GlobalActionCatalogEntry[];
+declare function providePraxisGlobalActionCatalog(): Provider[];
+
+type GlobalActionId = 'navigate' | 'openUrl' | 'showAlert' | 'log' | 'openDialog' | 'confirm' | 'alert' | 'prompt' | 'submitForm' | 'resetForm' | 'validateForm' | 'clearValidation' | 'saveFormDraft' | 'loadFormDraft' | 'clearFormDraft' | 'apiCall' | 'download' | 'copyToClipboard' | 'refreshOptions' | 'loadDependentData';
+type GlobalActionParam = {
+    required?: boolean;
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    example?: string;
+};
+interface GlobalActionSpec {
+    id: GlobalActionId;
+    label: string;
+    description: string;
+    param?: GlobalActionParam;
 }
+declare const GLOBAL_ACTION_CATALOG: GlobalActionSpec[];
 
-type DeviceKind = 'mobile' | 'tablet' | 'desktop';
-type OverlayPattern = 'modal' | 'drawer' | 'page' | 'bottom-sheet' | 'full-screen-dialog';
-interface OverlayDecisionContext {
-    device: DeviceKind;
-    fieldCount: number;
-    dependencyCount: number;
-}
-interface OverlayDecision {
-    pattern: OverlayPattern;
-    config?: Record<string, unknown>;
-    reason?: string;
-}
-interface OverlayRange {
-    min?: number;
-    max?: number;
-}
-interface OverlayRuleMatch {
-    device?: DeviceKind[];
-    fieldCount?: OverlayRange;
-    dependencyCount?: OverlayRange;
-    any?: OverlayRuleMatch[];
+interface SettingsPanelRef<T = any> {
+    applied$: Observable<T>;
+    saved$: Observable<T>;
 }
-interface OverlayRule {
-    match: OverlayRuleMatch;
-    use: OverlayDecision;
+interface SettingsPanelOpenContent<TInputs = any> {
+    component: Type<any>;
+    inputs?: TInputs;
 }
-interface OverlayThresholds {
-    fieldCount: {
-        small_max: number;
-        medium_max: number;
-    };
-    dependencyCount: {
-        low_max: number;
-        medium_max: number;
-    };
+interface SettingsPanelOpenOptions<TInputs = any> {
+    id: string;
+    title: string;
+    content: SettingsPanelOpenContent<TInputs>;
 }
-interface OverlayDecisionMatrix {
-    version: string;
-    description?: string;
-    thresholds: OverlayThresholds;
-    rules_ordered: OverlayRule[];
-    fallback: OverlayDecision;
-    ui_hints?: Record<string, unknown>;
+interface SettingsPanelBridge {
+    open<TInputs = any, TOut = any>(opts: SettingsPanelOpenOptions<TInputs>): SettingsPanelRef<TOut>;
 }
-interface OverlayDecider {
-    decide(ctx: OverlayDecisionContext): OverlayDecision;
-    explain?(ctx: OverlayDecisionContext): string;
+declare const SETTINGS_PANEL_BRIDGE: InjectionToken<SettingsPanelBridge>;
+declare const SETTINGS_PANEL_DATA: InjectionToken<any>;
+interface SettingsValueProvider {
+    isDirty$: Observable<boolean>;
+    isValid$: Observable<boolean>;
+    isBusy$: Observable<boolean>;
+    getSettingsValue(): any;
+    onSave?(): any;
+    reset?(): void;
 }
 
-declare const OVERLAY_DECIDER_DEBUG: InjectionToken<boolean>;
-declare class OverlayDeciderService {
-    private readonly matrix;
-    private readonly debug;
-    decide(ctx: OverlayDecisionContext): OverlayDecision;
-    explain(ctx: OverlayDecisionContext): string;
-    private evaluate;
-    private matches;
-    private log;
-    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayDeciderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayDeciderService>;
-}
+declare const TABLE_CONFIG_EDITOR: InjectionToken<Type<any>>;
+declare const STEPPER_CONFIG_EDITOR: InjectionToken<Type<any>>;
+declare const DYNAMIC_PAGE_SHELL_EDITOR: InjectionToken<Type<any>>;
+declare const DYNAMIC_PAGE_CONFIG_EDITOR: InjectionToken<Type<any>>;
 
-declare const OVERLAY_DECISION_MATRIX: InjectionToken<OverlayDecisionMatrix>;
-declare function provideOverlayDecisionMatrix(matrix?: OverlayDecisionMatrix): EnvironmentProviders;
+declare const PRAXIS_LOADING_CTX: HttpContextToken<LoadingContext | null>;
 
+interface MaterialTimeTrackShift {
+    id?: string;
+    label?: string;
+    start?: string | number;
+    end?: string | number;
+    color?: string;
+}
 interface MaterialTimeRangeMetadata extends FieldMetadata {
     controlType: typeof FieldControlType.TIME_RANGE;
     showSeconds?: boolean;
@@ -5129,6 +6511,8 @@ interface MaterialTimeRangeMetadata extends FieldMetadata {
     endPlaceholder?: string;
     startLabel?: string;
     endLabel?: string;
+    /** Inline gradient segments for turn/shift visualization in range slider track. */
+    inlineTimeTrackShifts?: Array<string | MaterialTimeTrackShift>;
     validators?: ValidatorOptions & {
         rangeMessage?: string;
         minDistanceMessage?: string;
@@ -5209,14 +6593,227 @@ interface FormHookDeclarationLite {
     timeoutMs?: number;
     args?: any;
 }
-interface FormHooksLayout {
-    beforeInit?: FormHookDeclarationLite[];
-    afterInit?: FormHookDeclarationLite[];
-    beforeValidate?: FormHookDeclarationLite[];
-    afterValidate?: FormHookDeclarationLite[];
-    beforeSubmit?: FormHookDeclarationLite[];
-    afterSubmit?: FormHookDeclarationLite[];
-    onError?: FormHookDeclarationLite[];
+interface FormHooksLayout {
+    beforeInit?: FormHookDeclarationLite[];
+    afterInit?: FormHookDeclarationLite[];
+    beforeValidate?: FormHookDeclarationLite[];
+    afterValidate?: FormHookDeclarationLite[];
+    beforeSubmit?: FormHookDeclarationLite[];
+    afterSubmit?: FormHookDeclarationLite[];
+    onError?: FormHookDeclarationLite[];
+}
+
+interface Specification<T extends object = any> {
+    isSatisfiedBy(obj: T): boolean;
+}
+
+interface FormActionButton {
+    id?: string;
+    visible: boolean;
+    label: string;
+    icon?: string;
+    className?: string;
+    style?: Record<string, any>;
+    color?: 'primary' | 'accent' | 'warn' | 'basic';
+    disabled?: boolean;
+    type?: 'button' | 'submit' | 'reset';
+    action?: string;
+    tooltip?: string;
+    loading?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    variant?: 'raised' | 'stroked' | 'flat' | 'fab';
+    shortcut?: string;
+}
+interface FormActionsLayout {
+    /**
+     * Configuration for the submit button
+     */
+    submit: FormActionButton;
+    /**
+     * Configuration for the cancel button
+     */
+    cancel: FormActionButton;
+    /**
+     * Configuration for the reset button
+     */
+    reset: FormActionButton;
+    /**
+     * Custom buttons
+     */
+    custom?: FormActionButton[];
+    /**
+     * Layout and behavior
+     */
+    position?: 'left' | 'center' | 'right' | 'justified' | 'split';
+    orientation?: 'horizontal' | 'vertical';
+    spacing?: 'compact' | 'normal' | 'spacious';
+    sticky?: boolean;
+    /** Exibir divisor superior (linha) acima da barra de ações */
+    divider?: boolean;
+    /**
+     * Structural placement of the actions bar within the form layout.
+     * - afterSections: render once after all sections (default)
+     * - insideLastSection: render inside the last section's container
+     * - top: render once before all sections
+     */
+    placement?: 'insideLastSection' | 'afterSections' | 'top';
+    /**
+     * Responsive settings
+     */
+    mobile?: {
+        position?: 'left' | 'center' | 'right' | 'justified';
+        orientation?: 'horizontal' | 'vertical';
+        collapseToMenu?: boolean;
+    };
+    containerClassName?: string;
+    containerStyles?: {
+        [key: string]: any;
+    };
+    showSaveButton?: boolean;
+    submitButtonLabel?: string;
+    showCancelButton?: boolean;
+    cancelButtonLabel?: string;
+    showResetButton?: boolean;
+    resetButtonLabel?: string;
+}
+interface FormApiLayout {
+    saveEndpoint?: string;
+    loadEndpoint?: string;
+    saveMethod?: 'POST' | 'PUT' | 'PATCH';
+    timeout?: number;
+    headers?: Record<string, string>;
+    idField?: string;
+    beforeSave?: string;
+    afterLoad?: string;
+}
+interface FormBehaviorLayout {
+    confirmOnUnsavedChanges?: boolean;
+    trackHistory?: boolean;
+    focusFirstError?: boolean;
+    scrollToErrors?: boolean;
+    clearAfterSave?: boolean;
+    redirectAfterSave?: string;
+    /** Disable subtle mount animation on initial render. */
+    disableMountAnimation?: boolean;
+    /** Optional mount animation tuning (ms/px). */
+    mountAnimation?: {
+        durationMs?: number;
+        offsetPx?: number;
+        staggerMs?: number;
+    };
+    /**
+     * Enables afterValidate hooks to run reactively on form.valueChanges.
+     * Default is false.
+     */
+    reactiveValidation?: boolean;
+    /** Debounce for reactive afterValidate hooks (ms). Default 150ms. */
+    reactiveValidationDebounceMs?: number;
+}
+interface FormMetadataLayout {
+    formCode?: string;
+    version?: string;
+    [key: string]: any;
+}
+interface FormMessagesLayout {
+    updateRegistrySuccess?: string;
+    createRegistrySuccess?: string;
+    updateRegistryError?: string;
+    createRegistryError?: string;
+    confirmations?: {
+        submit?: string;
+        cancel?: string;
+        reset?: string;
+        [customAction: string]: string | undefined;
+    };
+    customActions?: {
+        [actionId: string]: {
+            success?: string;
+            error?: string;
+            confirmation?: string;
+        };
+    };
+    loading?: {
+        submit?: string;
+        cancel?: string;
+        reset?: string;
+        [customAction: string]: string | undefined;
+    };
+    [key: string]: any;
+}
+interface FormRowLayout {
+    id: string;
+    name?: string;
+    label?: string;
+    orientation: 'horizontal' | 'vertical';
+    fields: FieldMetadata[];
+    styles?: {
+        [key: string]: any;
+    };
+    hiddenCondition?: string | Specification<any> | null;
+    visibilityCondition?: string | Specification<any> | null;
+}
+interface NestedFieldsetLayout extends FormRowLayout {
+    fieldsets?: FieldsetLayout[];
+}
+interface FieldsetLayout {
+    id: string;
+    title: string;
+    titleNew?: string;
+    titleView?: string;
+    titleEdit?: string;
+    orientation: 'horizontal' | 'vertical';
+    rows: FormRowLayout[];
+    hiddenCondition?: string | Specification<any> | null;
+}
+type FormRuleTargetType = 'field' | 'section' | 'action' | 'row' | 'column';
+interface FormLayoutRule {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Tipo de alvo. Ausente em regras legadas — deve ser inferido como 'field'.
+     */
+    targetType?: FormRuleTargetType;
+    /**
+     * IDs canônicos dos alvos (sem prefixo). Para compatibilidade, `targets` pode
+     * vir vazio e deve ser inferido a partir de `targetFields` legados.
+     */
+    targets?: string[];
+    /**
+     * Alias legado para alvos de campo (mantido para retrocompatibilidade).
+     */
+    targetFields?: string[];
+    /**
+     * Contexto legado (ex.: visibility/readOnly/validation). O runtime deve
+     * inferir propriedades a partir dele quando `properties` não for informado.
+     */
+    context?: 'visibility' | 'readOnly' | 'style' | 'validation' | 'notification';
+    effect: {
+        condition: string | Specification<any> | null;
+        properties?: Record<string, any>;
+        propertiesWhenFalse?: Record<string, any>;
+    };
+}
+interface FormLayout {
+    formTitle?: string;
+    formDescription?: string;
+    formTitleCreate?: string;
+    formDescriptionCreate?: string;
+    formTitleView?: string;
+    formDescriptionView?: string;
+    formTitleEdit?: string;
+    formDescriptionEdit?: string;
+    className?: string;
+    styles?: {
+        [key: string]: any;
+    };
+    actions?: FormActionsLayout;
+    api?: FormApiLayout;
+    behavior?: FormBehaviorLayout;
+    metadata?: FormMetadataLayout;
+    messages?: FormMessagesLayout;
+    fieldsets: FieldsetLayout[];
+    formRules?: FormLayoutRule[];
 }
 
 type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
@@ -5277,6 +6874,10 @@ interface FormSection {
     /** Optional icon name (Material Icons ligature or SVG name) */
     icon?: string;
     description?: string;
+    /** When true, allows the section content to be collapsed/expanded in the UI. */
+    collapsible?: boolean;
+    /** Initial collapsed state when `collapsible` is true. */
+    collapsed?: boolean;
     /** Optional extra space after the entire section (px). */
     gapBottom?: number;
     /** Optional gap below the title (px) */
@@ -5287,6 +6888,13 @@ interface FormSection {
     titleStyle?: string;
     /** Optional typography preset for the description */
     descriptionStyle?: string;
+    /** Optional colors for title/description (CSS color or token) */
+    titleColor?: string;
+    descriptionColor?: string;
+    /** Optional alignment for the header content */
+    headerAlign?: 'start' | 'center';
+    /** Optional tooltip for the section header */
+    headerTooltip?: string;
     rows: FormRow[];
 }
 interface FormConfig {
@@ -5313,6 +6921,24 @@ interface FormConfig {
     formRulesState?: unknown;
     /** Optional lifecycle hooks declared per stage */
     hooks?: FormHooksLayout;
+    /**
+     * Dicas e tooltips para modos de dados e modos globais de UI.
+     * Útil para padronizar mensagens didáticas no host.
+     */
+    hints?: FormModeHints;
+}
+interface FormModeHints {
+    dataModes: {
+        create: string;
+        edit: string;
+        view: string;
+    };
+    uiModes: {
+        presentation: string;
+        readonly: string;
+        disabled: string;
+        visible: string;
+    };
 }
 interface FormConfigMetadata {
     /** Configuration version for migration support */
@@ -5367,6 +6993,10 @@ declare function isValidFormConfig(config: any): config is FormConfig;
  * Cria configuração vazia para inicialização
  */
 declare function createEmptyFormConfig(): FormConfig;
+/**
+ * Default hint texts for data and UI modes.
+ */
+declare function getDefaultFormHints(): FormModeHints;
 /**
  * Merges field metadata into a FormConfig
  * Useful when combining layout with server-loaded metadata
@@ -5412,8 +7042,99 @@ declare function syncWithServerMetadata(localConfig: FormConfig, serverMetadata:
  */
 declare function convertFormLayoutToConfig(formLayout: any): FormConfig;
 
+interface FormValueChangeEvent {
+    formData: any;
+    changedField?: string;
+    previousValue?: any;
+    currentValue?: any;
+    changedFields: string[];
+    isValid: boolean;
+    entityId?: string | number;
+}
+interface ValidationError {
+    field: string;
+    type: 'required' | 'pattern' | 'min' | 'max' | 'email' | 'custom';
+    message: string;
+    currentValue?: any;
+    expectedValue?: any;
+}
+interface FormSubmitEvent {
+    stage: 'before' | 'after' | 'error';
+    formData: any;
+    isValid: boolean;
+    validationErrors?: ValidationError[];
+    entityId?: string | number;
+    operation: 'create' | 'update';
+    result?: any;
+    error?: any;
+}
+interface FormValidationEvent {
+    isValid: boolean;
+    errors: {
+        [fieldName: string]: ValidationError[];
+    };
+    validatedFields: string[];
+    invalidFields: string[];
+    formStatus: 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
+}
+interface FormEntityEvent {
+    operation: 'load' | 'create' | 'update' | 'delete';
+    entityId?: string | number;
+    entityData?: any;
+    success: boolean;
+    result?: any;
+    error?: any;
+    timestamp: Date;
+}
+interface FormReadyEvent {
+    formGroup: FormGroup;
+    fieldsMetadata: FieldMetadata[];
+    layout?: FormLayout;
+    hasEntity: boolean;
+    entityId?: string | number;
+}
+interface FormInitializationError {
+    stage: 'config-load' | 'schema-fetch' | 'sync' | 'form-build';
+    error: Error;
+    context?: {
+        formId?: string;
+        resourcePath?: string;
+        hasLocalConfig?: boolean;
+    };
+    recoverable: boolean;
+    userMessage: string;
+}
+interface FormCustomActionEvent {
+    actionId: string;
+    formData: any;
+    isValid: boolean;
+    source: 'button' | 'shortcut';
+}
+interface FormActionConfirmationEvent {
+    actionId: 'submit' | 'cancel' | 'reset' | string;
+    message: string;
+    confirmed: boolean;
+}
+
+type RulePropertyType = 'string' | 'boolean' | 'object' | 'enum' | 'number';
+interface RulePropertyDefinition {
+    name: string;
+    type: RulePropertyType;
+    label: string;
+    description?: string;
+    enumValues?: Array<{
+        value: string;
+        label: string;
+    }>;
+    category?: 'content' | 'appearance' | 'behavior' | 'layout' | 'validation';
+}
+type RulePropertySchema = Record<'field' | 'section' | 'action' | 'row' | 'column', RulePropertyDefinition[]>;
+declare const RULE_PROPERTY_SCHEMA: RulePropertySchema;
+
 type ActionDefinition = {
+    /** Global action id to execute (e.g., 'navigation.back', 'dialog.alert'). */
     type?: string;
+    /** Optional payload template for the action. */
     params?: Record<string, any>;
 };
 interface WidgetDefinition {
@@ -5421,7 +7142,7 @@ interface WidgetDefinition {
     id: string;
     /** Inputs to bind into the component instance */
     inputs?: Record<string, any>;
-    /** Map of component output name to action (currently forwarded as widgetEvent) */
+    /** Map of component output name to action (global action or 'emit'). */
     outputs?: Record<string, ActionDefinition | 'emit'>;
     /**
      * Optional explicit order for applying inputs. Keys listed here are applied first
@@ -5430,6 +7151,100 @@ interface WidgetDefinition {
     bindingOrder?: string[];
 }
 
+type WidgetShellActionPlacement = 'header' | 'window';
+interface WidgetShellAction {
+    /** Unique action id used for tracking and default emit name. */
+    id: string;
+    /** Optional label for text or outlined buttons. */
+    label?: string;
+    /** Optional icon name (Material or Praxis icon registry). */
+    icon?: string;
+    /** Tooltip text for the action. */
+    tooltip?: string;
+    /** Visual style of the action button. */
+    variant?: 'icon' | 'text' | 'outlined';
+    /** Placement inside the shell header. Defaults to 'header'. */
+    placement?: WidgetShellActionPlacement;
+    /** Output name to emit to the page builder (defaults to `shell:${id}`). */
+    emit?: string;
+    /** Optional command name to dispatch to the inner widget. */
+    command?: string;
+    /** Optional payload for action dispatch/emit. */
+    payload?: any;
+    /** Whether the action is disabled. */
+    disabled?: boolean;
+    /** Whether the action is visible. */
+    visible?: boolean;
+}
+interface WidgetShellWindowActions {
+    /** Show collapse/expand control in the header. */
+    collapsible?: boolean;
+    /** Show fullscreen toggle in the header. */
+    fullscreen?: boolean;
+}
+interface WidgetShellConfig {
+    /** Shell type. 'dashboard-card' enables the default dashboard styling. */
+    kind?: 'dashboard-card' | 'none';
+    /** Optional preset id to resolve appearance defaults. */
+    preset?: string;
+    /** Header icon name. */
+    icon?: string;
+    /** Header title. */
+    title?: string;
+    /** Header subtitle. */
+    subtitle?: string;
+    /** Whether to show the header; defaults to true when title/icon/actions exist. */
+    showHeader?: boolean;
+    /** Header + window actions. */
+    actions?: WidgetShellAction[];
+    /** Built-in window actions configuration. */
+    windowActions?: WidgetShellWindowActions;
+    /** Initial collapsed state. */
+    collapsed?: boolean;
+    /** Initial expanded (fullscreen) state. */
+    expanded?: boolean;
+    /** Initial fullscreen state. */
+    fullscreen?: boolean;
+    /** Optional appearance overrides for card, header, and typography. */
+    appearance?: {
+        card?: {
+            background?: string;
+            borderColor?: string;
+            borderRadius?: string;
+            shadow?: string;
+        };
+        header?: {
+            background?: string;
+            borderColor?: string;
+            titleColor?: string;
+            subtitleColor?: string;
+            iconColor?: string;
+        };
+        body?: {
+            background?: string;
+            textColor?: string;
+            padding?: string;
+        };
+        typography?: {
+            titleSize?: string;
+            titleWeight?: string;
+            subtitleSize?: string;
+        };
+    };
+}
+interface WidgetShellActionEvent {
+    /** Action id. */
+    id: string;
+    /** Optional command name to dispatch to the inner widget. */
+    command?: string;
+    /** Optional emit name to propagate to the page builder. */
+    emit?: string;
+    /** Optional payload for the action. */
+    payload?: any;
+    /** Original action definition, when available. */
+    action?: WidgetShellAction;
+}
+
 interface GridItemLayout {
     /** 1-based column start */
     col: number;
@@ -5445,6 +7260,7 @@ interface GridWidgetInstance {
     definition: WidgetDefinition;
     layout: GridItemLayout;
     className?: string;
+    shell?: WidgetShellConfig;
 }
 interface GridPageDefinition {
     widgets: GridWidgetInstance[];
@@ -5573,6 +7389,24 @@ interface BackConfig {
     confirmOnDirty?: boolean;
 }
 
+type LoadingPhase = 'config' | 'schema' | 'render' | 'data' | 'idle';
+type LoadingStatus = 'loading' | 'success' | 'error';
+interface LoadingState {
+    phase: LoadingPhase;
+    status: LoadingStatus;
+    message?: string;
+    percent?: number;
+    error?: unknown;
+    context?: {
+        componentType?: string;
+        componentId?: string;
+        resourcePath?: string;
+    };
+    timestamp?: string;
+}
+
+declare const DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP: Record<string, FieldControlType>;
+
 declare const AllowedFileTypes: {
     readonly ALL: "*/*";
     readonly IMAGES: "image/*";
@@ -5761,6 +7595,12 @@ declare function resolveOffset(offset?: ColumnOffset): Required<ColumnOffset>;
 declare function resolveOrder(order?: ColumnOrder): Required<ColumnOrder>;
 declare function resolveHidden(hidden?: ColumnHidden): Required<ColumnHidden>;
 
+/**
+ * Migra regras legadas (context/targetFields) para o formato canônico
+ * `targetType/targets/effect.properties`.
+ */
+declare function migrateFormLayoutRule(rule: any): FormLayoutRule;
+
 /**
  * Text transformation utilities for display and persistence.
  *
@@ -5800,6 +7640,265 @@ declare function deepMerge<T>(left: T, right: Partial<T> | undefined): T;
  */
 declare function fillUndefined<T>(target: T, defaults: Partial<T> | undefined): T;
 
+interface ResolvePresetOptions {
+    timezone?: string;
+    startOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    now?: Date;
+    /** If true, require every day in range to pass filter, else only start/end. */
+    strictFilter?: boolean;
+    /** Optional date filter to validate computed ranges. */
+    dateFilter?: (d: Date | null) => boolean;
+    /** Optional min/max clamp. */
+    minDate?: Date | null;
+    maxDate?: Date | null;
+}
+/** Normalize a date to start of day (00:00:00.000) respecting timezone if provided. */
+declare function normalizeStart(date: Date, timezone?: string): Date;
+/** Normalize a date to end of day (23:59:59.999) respecting timezone if provided. */
+declare function normalizeEnd(date: Date, timezone?: string): Date;
+declare function clampRange(range: DateRangeValue, minDate?: Date | null, maxDate?: Date | null, timezone?: string): DateRangeValue;
+declare function isRangeValidForFilter(range: DateRangeValue, dateFilter?: (d: Date | null) => boolean, strict?: boolean): boolean;
+/** Build built-in presets based on locale and DateAdapter. */
+declare function resolveBuiltinPresets(locale: string, dateAdapter: DateAdapter<Date>, opts?: ResolvePresetOptions): Record<string, DateRangePreset>;
+
+type FieldControlTypeValue$1 = (typeof FieldControlType)[keyof typeof FieldControlType];
+declare function normalizeControlTypeToken(value: unknown): string;
+declare function normalizeControlTypeKey(value: unknown): string;
+declare function resolveControlTypeAlias(value: unknown, fallback?: FieldControlTypeValue$1 | string): FieldControlTypeValue$1 | string;
+
+type FieldControlTypeValue = (typeof FieldControlType)[keyof typeof FieldControlType];
+declare const INLINE_FILTER_CONTROL_TYPES: Readonly<{
+    readonly SELECT: "filter-select-inline";
+    readonly SEARCHABLE_SELECT: "filter-searchable-select-inline";
+    readonly ASYNC_SELECT: "filter-async-select-inline";
+    readonly ENTITY_LOOKUP: "filter-entity-lookup-inline";
+    readonly AUTOCOMPLETE: "filter-autocomplete-inline";
+    readonly NUMBER: "filter-number-inline";
+    readonly CURRENCY: "filter-currency-inline";
+    readonly CURRENCY_RANGE: "filter-currency-range-inline";
+    readonly MULTI_SELECT: "filter-multiselect-inline";
+    readonly INPUT: "filter-input-inline";
+    readonly TOGGLE: "filter-toggle-inline";
+    readonly RANGE: "filter-range-inline";
+    readonly DATE: "filter-date-inline";
+    readonly DATE_RANGE: "filter-date-range-inline";
+    readonly TIME: "filter-time-inline";
+    readonly TIME_RANGE: "filter-time-range-inline";
+    readonly TREE_SELECT: "filter-tree-select-inline";
+    readonly RATING: "filter-rating-inline";
+    readonly DISTANCE_RADIUS: "filter-distance-radius-inline";
+    readonly PIPELINE_STATUS: "filter-pipeline-status-inline";
+    readonly SCORE_PRIORITY: "filter-score-priority-inline";
+    readonly RELATIVE_PERIOD: "filter-relative-period-inline";
+    readonly SENTIMENT: "filter-sentiment-inline";
+    readonly COLOR_LABEL: "filter-color-label-inline";
+}>;
+type InlineFilterControlType = (typeof INLINE_FILTER_CONTROL_TYPES)[keyof typeof INLINE_FILTER_CONTROL_TYPES];
+declare const INLINE_FILTER_CONTROL_TYPE_VALUES: readonly InlineFilterControlType[];
+declare const INLINE_FILTER_CONTROL_TYPE_SET: ReadonlySet<InlineFilterControlType>;
+declare const INLINE_FILTER_ALIAS_TOKEN_TO_CONTROL_TYPE: Readonly<Record<string, InlineFilterControlType>>;
+declare const INLINE_FILTER_ALIAS_TOKENS: readonly string[];
+declare const INLINE_FILTER_ALIAS_TOKEN_TO_BASE_CONTROL_TYPE: Readonly<Record<string, FieldControlTypeValue>>;
+declare function resolveInlineFilterControlTypeAlias(value: unknown): InlineFilterControlType | undefined;
+declare function resolveInlineFilterAliasToBaseControlType(value: unknown): FieldControlTypeValue | undefined;
+declare function isInlineFilterControlType(value: unknown): value is InlineFilterControlType;
+
+type GlobalActionFieldType = 'text' | 'textarea' | 'number' | 'select' | 'toggle' | 'json';
+interface GlobalActionFieldOption {
+    value: string;
+    label: string;
+}
+interface GlobalActionField {
+    key: string;
+    label: string;
+    type: GlobalActionFieldType;
+    hint?: string;
+    placeholder?: string;
+    required?: boolean;
+    options?: GlobalActionFieldOption[];
+    rows?: number;
+    dependsOnKey?: string;
+    dependsOnValue?: string;
+}
+interface GlobalActionUiSchema {
+    id: GlobalActionId;
+    label: string;
+    fields: GlobalActionField[];
+}
+declare const GLOBAL_ACTION_UI_SCHEMAS: GlobalActionUiSchema[];
+declare function getGlobalActionUiSchema(id: string | undefined): GlobalActionUiSchema | undefined;
+
+type AiValueKind = 'boolean' | 'string' | 'number' | 'enum' | 'expression' | 'object' | 'array';
+interface AiCapabilityCategoryMap {
+    identity: true;
+    appearance: true;
+    validation: true;
+    data: true;
+    behavior: true;
+    layout: true;
+    accessibility: true;
+    dependency: true;
+    transform: true;
+    form_config: true;
+    events: true;
+    misc: true;
+}
+type AiCapabilityCategory = keyof AiCapabilityCategoryMap;
+interface AiCapability {
+    /** Path com [] para arrays (ex.: fieldMetadata[].label) */
+    path: string;
+    /** Categoria lógica para agrupamento */
+    category: AiCapabilityCategory;
+    /** Tipo de dado esperado */
+    valueKind: AiValueKind;
+    /** Valores permitidos para enums */
+    allowedValues?: Array<string | number>;
+    /** Descrição semântica para a IA */
+    description?: string;
+    /** Se true, exige confirmação extra por ser destrutivo ou impactante */
+    critical?: boolean;
+    /** Exemplos de intenção do usuário (Few-Shot) */
+    intentExamples?: string[];
+    /** Dependência condicional (ex.: requer outro campo) */
+    dependsOn?: string;
+    /** Exemplo de valor */
+    example?: string;
+    /** Observações de segurança */
+    safetyNotes?: string;
+}
+interface AiCapabilityCatalog {
+    version: string;
+    capabilities: AiCapability[];
+    notes: string[];
+    enums: Record<string, Array<string | number>>;
+    targets?: string[];
+}
+interface AiConcept {
+    id: string;
+    title: string;
+    description: string;
+    rules: string[];
+    syntax?: string;
+    examples: string[];
+    antiPatterns?: string[];
+}
+type AiConceptPack = Record<string, AiConcept>;
+
+/**
+ * Catálogo de capacidades genéricas de FieldMetadata para uso da IA.
+ * Baseado em projects/praxis-core/src/lib/models/component-metadata.interface.ts
+ */
+
+type CapabilityCategory$1 = AiCapabilityCategory;
+type ValueKind$1 = AiValueKind;
+interface Capability$1 extends AiCapability {
+    category: CapabilityCategory$1;
+}
+interface CapabilityCatalog$1 extends AiCapabilityCatalog {
+    capabilities: Capability$1[];
+}
+declare const FIELD_METADATA_CAPABILITIES: CapabilityCatalog$1;
+declare function getFieldMetadataCapabilities(): Capability$1[];
+
+/**
+ * Capabilities catalog for Praxis Dynamic Page (praxis-dynamic-page).
+ * Paths follow WidgetPageDefinition shape under "page".
+ */
+
+declare module "./index" {
+    interface AiCapabilityCategoryMap {
+        page: true;
+        layout: true;
+        widgets: true;
+        shell: true;
+        connections: true;
+        context: true;
+    }
+}
+type CapabilityCategory = AiCapabilityCategory;
+type ValueKind = AiValueKind;
+interface Capability extends AiCapability {
+    category: CapabilityCategory;
+}
+interface CapabilityCatalog extends AiCapabilityCatalog {
+    capabilities: Capability[];
+}
+declare const DYNAMIC_PAGE_AI_CAPABILITIES: CapabilityCatalog;
+
+type ComponentContextOptionMode = 'enum' | 'suggested';
+interface ComponentContextOption {
+    value: string | number;
+    label?: string;
+    example?: string;
+}
+interface ComponentContextOptionsByPathEntry {
+    mode: ComponentContextOptionMode;
+    options: ComponentContextOption[];
+}
+interface ComponentActionParam {
+    name: string;
+    type: 'ENUM' | 'BOOLEAN' | 'STRING' | 'NUMBER';
+    options?: string[];
+    description?: string;
+}
+interface ComponentContextAction {
+    id: string;
+    keywords?: string[];
+    patchTemplate: any;
+    safetyNotes?: string;
+    /**
+     * Define o tipo de operação associado à ação.
+     * Usado para diferenciar criação/edição/remoção em fluxos determinísticos.
+     */
+    operation?: 'create' | 'update' | 'delete' | 'read';
+    /**
+     * Indica se o target deve existir antes de aplicar a ação.
+     * Ex: criar coluna nova não exige target pré-existente.
+     */
+    requiresExistingTarget?: boolean;
+    /**
+     * Escopo da ação para resolução determinística.
+     * - GLOBAL: Ação afeta todo o componente (não exige target).
+     * - COLUMN: Ação afeta uma coluna específica (exige target).
+     * - ROW: Ação afeta uma linha ou configuração de linhas.
+     */
+    scope?: 'GLOBAL' | 'COLUMN' | 'ROW';
+    /**
+     * Tipo esperado para o valor da ação.
+     * Ajuda a decidir se exibe toggle, select ou input.
+     */
+    valueType?: 'BOOLEAN' | 'ENUM' | 'STRING' | 'NUMBER' | 'OBJECT';
+    /**
+     * Valor padrão caso o usuário não especifique (ex: true para enables).
+     */
+    defaultValue?: any;
+    /**
+     * Definição dos parâmetros utilizados no template ({{params.X}}).
+     * Usado para popular opções em clarificações.
+     */
+    params?: ComponentActionParam[];
+    /**
+     * IDs de conceitos (AiConcepts) que devem ser carregados no prompt
+     * quando esta ação for candidata. Ex: ['computed-logic'].
+     */
+    relatedConcepts?: string[];
+}
+interface ComponentContextPack {
+    version: string;
+    optionsByPath: Record<string, ComponentContextOptionsByPathEntry>;
+    actionCatalog: ComponentContextAction[];
+    fieldResolvers: Record<string, string[]>;
+    hints?: string[];
+}
+interface ComponentMergePatch<TConfig extends Record<string, unknown> = Record<string, unknown>> {
+    mode: 'merge';
+    patch: Partial<TConfig>;
+    intent?: string;
+    planRef?: string;
+}
+
+declare const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK: ComponentContextPack;
+
 /**
  * Carrega dinamicamente um componente "widget" (de página) a partir de um id registrado
  * no ComponentMetadataRegistry e aplica bindings declarados em JSON (WidgetDefinition).
@@ -5821,6 +7920,8 @@ declare class DynamicWidgetLoaderDirective implements OnInit, OnChanges, OnDestr
     private compRef?;
     private currentId?;
     private outputSubs;
+    /** Dispatch a shell action to the inner widget instance when supported. */
+    dispatchAction(action: WidgetShellActionEvent): boolean;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
@@ -5833,8 +7934,41 @@ declare class DynamicWidgetLoaderDirective implements OnInit, OnChanges, OnDestr
     private resolveValue;
     private lookup;
     private validateAgainstMetadata;
+    private coercePrimitive;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicWidgetLoaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicWidgetLoaderDirective, "[dynamicWidgetLoader]", never, { "widget": { "alias": "dynamicWidgetLoader"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoWireOutputs": { "alias": "autoWireOutputs"; "required": false; }; }, { "widgetEvent": "widgetEvent"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicWidgetLoaderDirective, "[dynamicWidgetLoader]", ["dynamicWidgetLoader"], { "widget": { "alias": "dynamicWidgetLoader"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoWireOutputs": { "alias": "autoWireOutputs"; "required": false; }; }, { "widgetEvent": "widgetEvent"; }, never, never, true, never>;
+}
+
+type ActionList = WidgetShellAction[];
+type Appearance = WidgetShellConfig['appearance'];
+declare const BUILTIN_SHELL_PRESETS: Record<string, NonNullable<Appearance>>;
+declare class WidgetShellComponent implements OnChanges {
+    shell?: WidgetShellConfig | null;
+    context?: Record<string, any> | null;
+    action: EventEmitter<WidgetShellActionEvent>;
+    loader?: DynamicWidgetLoaderDirective;
+    get appearance(): WidgetShellConfig['appearance'];
+    collapsed: boolean;
+    expanded: boolean;
+    fullscreen: boolean;
+    ngOnChanges(): void;
+    get shellEnabled(): boolean;
+    get showHeader(): boolean;
+    get headerActions(): ActionList;
+    get visibleHeaderActions(): ActionList;
+    get overflowHeaderActions(): ActionList;
+    private get maxHeaderActions();
+    get windowActions(): ActionList;
+    onAction(action: WidgetShellAction, ev: MouseEvent): void;
+    stopIfExpanded(ev: MouseEvent): void;
+    closeOverlay(): void;
+    private handleWindowAction;
+    private buildWindowActions;
+    private isVisible;
+    private resolvePresetAppearance;
+    private mergeAppearance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetShellComponent, "praxis-widget-shell", never, { "shell": { "alias": "shell"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "action": "action"; }, ["loader"], ["*"], true, never>;
 }
 
 interface WidgetInstance {
@@ -5842,6 +7976,8 @@ interface WidgetInstance {
     definition: WidgetDefinition;
     /** Optional CSS classes or layout hints */
     className?: string;
+    /** Optional shell config for standardized widget framing. */
+    shell?: WidgetShellConfig;
 }
 interface WidgetConnection {
     from: {
@@ -5869,11 +8005,29 @@ interface WidgetConnection {
         distinctBy?: string;
     };
 }
+type WidgetPageOrientation = 'vertical' | 'columns';
+interface WidgetPageLayout {
+    /** Layout orientation for widget grid. */
+    orientation?: WidgetPageOrientation;
+    /** Column count when using columns orientation. */
+    columns?: number;
+    /** CSS gap value for grid spacing (e.g., '16px'). */
+    gap?: string;
+    /** Optional responsive columns by breakpoint (sm/md/lg/xl). */
+    breakpoints?: {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+}
 interface WidgetPageDefinition {
     widgets: WidgetInstance[];
     connections?: WidgetConnection[];
     /** Optional page-wide context available to all widgets */
     context?: Record<string, any>;
+    /** Optional layout configuration for the widget grid */
+    layout?: WidgetPageLayout;
 }
 
 declare class ConnectionManagerService {
@@ -5907,31 +8061,91 @@ declare class ConnectionManagerService {
 
 declare class DynamicWidgetPageComponent implements OnChanges {
     private conn;
+    private settingsPanel;
+    private defaultShellEditor;
+    private defaultPageEditor;
     page?: WidgetPageDefinition | string;
     context?: Record<string, any> | null;
     strictValidation: boolean;
-    debug: boolean;
+    /** Enables lightweight editing affordances (shell + page layout). */
+    editModeEnabled: boolean;
+    /** Shows page settings button when edit mode is enabled. */
+    showPageSettingsButton: boolean;
+    /** Optional editor component override for widget shell settings. */
+    shellEditorComponent?: Type<any>;
+    /** Optional editor component override for page settings. */
+    pageEditorComponent?: Type<any>;
+    /** Enables automatic persistence (load/save) for the page definition. */
+    autoPersist: boolean;
+    /** Optional identity to scope persistence (tenant/user/route). */
+    pageIdentity?: PageIdentity;
+    /** Optional instance key for pages rendered multiple times. */
+    componentInstanceId?: string;
+    pageChange: EventEmitter<WidgetPageDefinition>;
     widgets: i0.WritableSignal<WidgetInstance[]>;
     mergedContext: Record<string, any>;
-    constructor(conn: ConnectionManagerService);
+    pageGap: string;
+    gridTemplateColumns: string;
+    private pageDefinition?;
+    private layout?;
+    private appliedPersisted;
+    private isHydrating;
+    private persistenceReady;
+    private warnedMissingKey;
+    private readonly globalActions;
+    private readonly storage;
+    private readonly componentKeys;
+    private readonly route;
+    constructor(conn: ConnectionManagerService, settingsPanel: SettingsPanelBridge | null, defaultShellEditor: Type<any> | null, defaultPageEditor: Type<any> | null);
     ngOnChanges(changes: SimpleChanges): void;
     onWidgetEvent(fromKey: string, evt: {
         sourceId: string;
         output?: string;
         payload?: any;
     }): void;
+    onShellAction(fromKey: string, evt: WidgetShellActionEvent): void;
+    private handleSetInputCommand;
     private mergeOrder;
+    private maybeExecuteMappedAction;
+    private maybeExecuteGlobalCommand;
+    private resolveActionPayload;
+    private resolveTemplate;
+    private lookup;
+    openWidgetShellSettings(key: string): void;
+    openPageSettings(): void;
+    private applyWidgetShell;
+    private applyPageLayout;
+    private applyPageUpdate;
+    private applyLayout;
+    private mergeContext;
+    onWindowResize(): void;
+    private resolveColumns;
+    private ensurePageDefinition;
     private parsePage;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicWidgetPageComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicWidgetPageComponent, "praxis-dynamic-page", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, never, true, never>;
+    private applyEditShellActions;
+    private savePage;
+    private loadPersistedPage;
+    private storageKey;
+    private componentKeyId;
+    private buildPageScopeId;
+    private warnMissingKey;
+    private sanitizeSegment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicWidgetPageComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicWidgetPageComponent, "praxis-dynamic-page", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; "showPageSettingsButton": { "alias": "showPageSettingsButton"; "required": false; }; "shellEditorComponent": { "alias": "shellEditorComponent"; "required": false; }; "pageEditorComponent": { "alias": "pageEditorComponent"; "required": false; }; "autoPersist": { "alias": "autoPersist"; "required": false; }; "pageIdentity": { "alias": "pageIdentity"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
 }
 
+/** Metadata for Praxis Dynamic Page component */
+declare const PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA: ComponentDocMeta;
+/**
+ * Provider que registra o metadata no ComponentMetadataRegistry durante o bootstrap.
+ */
+declare function providePraxisDynamicPageMetadata(): Provider;
+
 declare class DynamicGridPageComponent implements OnChanges {
     private conn;
     page?: GridPageDefinition | string;
     context?: Record<string, any> | null;
     strictValidation: boolean;
-    debug: boolean;
     /** Optional code-level grid options. Editor (page.options) takes precedence over these. */
     gridOptions?: Partial<{
         cols: number;
@@ -5942,6 +8156,7 @@ declare class DynamicGridPageComponent implements OnChanges {
     editModeEnabled: boolean;
     widgets: i0.WritableSignal<GridWidgetInstance[]>;
     mergedContext: Record<string, any>;
+    private readonly globalActions;
     private selectedKey;
     private cols;
     private _rowHeight;
@@ -5959,12 +8174,18 @@ declare class DynamicGridPageComponent implements OnChanges {
         output?: string;
         payload?: any;
     }): void;
+    onShellAction(fromKey: string, evt: WidgetShellActionEvent): void;
     isSelected(key?: string): boolean;
     onTileClick(key?: string, ev?: Event): void;
     private mergeOrder;
+    private maybeExecuteMappedAction;
+    private maybeExecuteGlobalCommand;
+    private resolveActionPayload;
+    private resolveTemplate;
+    private lookup;
     private parsePage;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicGridPageComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicGridPageComponent, "praxis-dynamic-grid-page", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicGridPageComponent, "praxis-dynamic-grid-page", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "gridOptions": { "alias": "gridOptions"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 interface EmptyAction {
@@ -5980,8 +8201,9 @@ declare class EmptyStateCardComponent {
     primaryAction?: EmptyAction;
     secondaryActions: EmptyAction[];
     inline: boolean;
+    tone: 'neutral' | 'primary' | 'secondary';
     static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateCardComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateCardComponent, "praxis-empty-state-card", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "primaryAction": { "alias": "primaryAction"; "required": false; }; "secondaryActions": { "alias": "secondaryActions"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateCardComponent, "praxis-empty-state-card", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "primaryAction": { "alias": "primaryAction"; "required": false; }; "secondaryActions": { "alias": "secondaryActions"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class ResourceQuickConnectComponent implements SettingsValueProvider {
@@ -5992,6 +8214,9 @@ declare class ResourceQuickConnectComponent implements SettingsValueProvider {
     updateState(): void;
     getSettingsValue(): any;
     onSave(): any;
+    showInvalid(): boolean;
+    normalizedPath(): string;
+    private isValidPath;
     static ɵfac: i0.ɵɵFactoryDeclaration<ResourceQuickConnectComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ResourceQuickConnectComponent, "praxis-resource-quick-connect", never, { "resourcePath": { "alias": "resourcePath"; "required": false; }; }, {}, never, never, true, never>;
 }
@@ -6003,6 +8228,7 @@ declare class PraxisIconPickerComponent {
     icons: string[];
     selected: EventEmitter<string>;
     cancel: EventEmitter<void>;
+    searchInput?: ElementRef<HTMLInputElement>;
     query: string;
     filtered: string[];
     selectedFamily: 'mi' | 'mso' | 'ms' | 'msr' | 'mss';
@@ -6010,13 +8236,16 @@ declare class PraxisIconPickerComponent {
     onFilter(): void;
     choose(icon: string): void;
     onEsc(ev: Event): void;
+    onGlobalKey(ev: KeyboardEvent): void;
     confirmTyped(): void;
+    isSelectedIcon(icon: string): boolean;
     onFamilyChange(val: any): void;
     clear(): void;
     onCancel(): void;
     buildValue(name: string): string;
     previewValue(): string;
     iconClassForFamily(fam: string): string;
+    private focusSearch;
     familyFromValue(v?: string): {
         family: 'mi' | 'mso' | 'msr' | 'mss';
         name: string;
@@ -6076,6 +8305,70 @@ declare function normalizeFormMetadata(list: FieldMetadata[] | undefined | null)
 /** Normalize a full FormConfig object */
 declare function normalizeFormConfig(config: FormConfig): FormConfig;
 
+/** Minimal metadata about the backend schema source. */
+interface SchemaMetaInfo {
+    /** API path used to resolve the schema (e.g., /api/employees/all or /filter) */
+    path: string;
+    /** Operation used when fetching the schema (get|post) */
+    operation: string;
+    /** Schema type requested (response|request) */
+    schemaType: string;
+    /** Optional strong hash returned by server (X-Schema-Hash/ETag) */
+    schemaHash?: string;
+    /** Optional resource id field name provided by server */
+    idField?: string;
+    /** API origin used to fetch (useful when not same-origin) */
+    apiOrigin?: string;
+    /** Client-side composed id (path|operation|schemaType|...) */
+    schemaId?: string;
+}
+/** Context consumed by SchemaViewer to present component/config/schema metadata. */
+interface SchemaViewerContext {
+    /** Registered component id (ComponentMetadataRegistry) */
+    componentId: string;
+    /** Optional user-friendly title for the viewer */
+    title?: string;
+    /** Config JSON used by the example (e.g., TabsMetadata, TableConfig) */
+    rawConfig?: unknown;
+    /** Optional pre-computed effective config (raw + defaults) */
+    effectiveConfig?: unknown;
+    /** Raw backend schema JSON (OpenAPI/JSON Schema + x-ui) */
+    backendSchema?: unknown;
+    /** Optional meta associated with backendSchema */
+    schemaMeta?: SchemaMetaInfo;
+    /** Optional already normalized field definitions */
+    normalizedFields?: FieldDefinition[];
+    /** Free-form notes shown on top of the viewer */
+    notes?: string;
+}
+
+declare class SchemaViewerComponent implements OnChanges {
+    private readonly registry;
+    private readonly normalizer;
+    private readonly injected;
+    context?: SchemaViewerContext;
+    private _ctx;
+    ctx: i0.Signal<SchemaViewerContext | undefined>;
+    private _componentMeta;
+    componentMeta: i0.Signal<ComponentDocMeta | undefined>;
+    private _normalizedFields;
+    normalizedFields: i0.Signal<FieldDefinition[]>;
+    private _copyNote;
+    copyNote: i0.Signal<string | null>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private refresh;
+    hasAnyData(): boolean;
+    copyAll(): void;
+    copySection(kind: 'component' | 'config' | 'backend' | 'fields'): void;
+    private copyPayload;
+    private flashNote;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SchemaViewerComponent, "praxis-schema-viewer", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Optional DI token used by SchemaViewer when input is not provided. */
+declare const SCHEMA_VIEWER_CONTEXT: InjectionToken<SchemaViewerContext>;
+
 interface SchemaIdParams {
     path: string;
     operation?: string;
@@ -6104,6 +8397,7 @@ type FetchWithEtagResult = {
     schema: any;
     schemaHash: string;
 };
+declare function parseJsonResponseOrEmpty(res: Response, context?: string): Promise<any>;
 declare function fetchWithETag(params: FetchWithEtagParams): Promise<FetchWithEtagResult>;
 
 interface CacheEntry {
@@ -6167,6 +8461,13 @@ declare class LocalStorageCacheAdapter implements CacheAdapter {
     private broadcast;
 }
 
+declare class MemoryCacheAdapter implements CacheAdapter {
+    private mem;
+    get(schemaId: string): Promise<CacheEntry | undefined>;
+    set(schemaId: string, entry: CacheEntry): Promise<void>;
+    remove(schemaId: string): Promise<void>;
+}
+
 interface GetSchemaParams extends SchemaIdParams {
     baseUrl: string;
 }
@@ -6259,5 +8560,5 @@ declare function provideFormHookPresets(presets: Array<FormHookPreset>): Provide
 /** Register a whitelist of allowed hook ids/patterns. */
 declare function provideHookWhitelist(allowed: Array<string | RegExp>): Provider[];
 
-export { API_URL, AllowedFileTypes, ApiEndpoint, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentMetadataRegistry, ConnectionManagerService, DEFAULT_TABLE_CONFIG, DynamicFormService, DynamicGridPageComponent, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EmptyStateCardComponent, ErrorMessageService, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FormHooksRegistry, GLOBAL_CONFIG, GenericCrudService, GlobalConfigService, IconPickerService, IconPosition, IconSize, LocalConnectionStorage, LocalStorageCacheAdapter, LocalStorageConfigService, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, OverlayDeciderService, PraxisCore, PraxisIconDirective, PraxisIconPickerComponent, ResourceQuickConnectComponent, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SchemaMetadataClient, SchemaNormalizerService, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryService, ValidationPattern, applyLocalCustomizations$1 as applyLocalCustomizations, applyLocalCustomizations as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildHeaders, buildPageKey, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getEssentialConfig, getReferencedFieldMetadata, getTextTransformer, isCssTextTransform, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergeTableConfigs, minWordsValidator, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, notifySuccessHook, prefillFromContextHook, provideDefaultFormHooks, provideFormHookPresets, provideFormHooks, provideGlobalConfig, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveHidden, resolveOffset, resolveOrder, resolveSpan, slugify, stripMasksHook, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, trim, uniqueAsyncValidator, urlValidator, withMessage };
-export type { AccessibilityConfig, ActionDefinition, ActionMessagesConfig, AnimationConfig, AnnouncementConfig, ApiUrlConfig, ApiUrlEntry, BackConfig, BaseMaterialInputMetadata, BatchDeleteOptions, BatchDeleteProgress, BatchDeleteResult, BorderConfig, Breakpoint, BuiltValidators, BulkAction, BulkActionsConfig, CacheAdapter, CacheConfig, CacheEntry, ColorConfig, ColumnAlign, ColumnDefinition, ColumnHidden, ColumnOffset, ColumnOrder, ColumnSpan, ComponentDocMeta, ComponentMetadata, ConfigMetadata, ConfigStorage, ConfirmationConfig, ConnectionConfigV1, ConnectionStorage, ContextAction, ContextActionsConfig, BackConfig as CoreBackConfig, CoreFieldMetadata, CrudOperationOptions, CsvExportConfig, CurrencyLocaleConfig, CursorPage, CursorRequest, CustomizationLog, DataConfig, DataTransformation, DataValidationConfig, DateRangePreset, DateRangeValue, DateTimeLocaleConfig, DebounceConfig, DeviceKind, DraggingConfig, ElevationConfig, EmptyAction, EmptyStateConfig, EndpointConfig, EnhancedValidationConfig, ExcelExportConfig, ExcelStylingConfig, ExportConfig, ExportFormat, ExportMessagesConfig, ExportTemplate, FetchWithEtagParams, FetchWithEtagResult, FieldConflict, FieldDefinition, FieldMetadata, FieldModification, FieldOption, FieldsetLayout, FilterOptions, FilteringConfig, FormActionButton, FormActionConfirmationEvent, FormActionsLayout, FormApiLayout, FormBehaviorLayout, FormColumn, FormConfig, FormConfigMetadata, FormConfigState, FormCustomActionEvent, FormEntityEvent, FormHook, FormHookContext, FormHookDeclaration, FormHookDeclarationLite, FormHookOutcome, FormHookPreset, FormHookPresetMatch, FormHookStage, FormHookStatus, FormHooksLayout, FormInitializationError, FormLayout, FormLayoutRule, FormMessagesLayout, FormMetadataLayout, FormOpenMode, FormReadyEvent, FormRow, FormRowLayout, FormRuleContext, FormSection, FormSubmitEvent, FormValidationEvent, FormValueChangeEvent, FormattingLocaleConfig, GeneralExportConfig, GetSchemaParams, GlobalConfig, GlobalCrudActionDefaults, GlobalCrudConfig, GlobalCrudDefaults, GlobalDialogAction, GlobalDialogAnimation, GlobalDialogAriaRole, GlobalDialogConfig, GlobalDialogConfigEntry, GlobalDialogPosition, GlobalDialogStyles, GlobalDynamicFieldsAsyncSelectConfig, GlobalDynamicFieldsCascadeConfig, GlobalDynamicFieldsConfig, GlobalTableConfig, GridItemLayout, GridPageDefinition, GridPageDefinitionWithIds, GridWidgetInstance, HookResolver, InteractionConfig, JsonExportConfig, KeyboardAccessibilityConfig, LazyLoadingConfig, LegacyTableConfig, LoadingConfig, LocalizationConfig, LocateRequest, MarginConfig, MaterialAutocompleteMetadata, MaterialButtonMetadata, MaterialButtonToggleMetadata, MaterialCheckboxMetadata, MaterialChipsMetadata, MaterialColorInputMetadata, MaterialColorPickerMetadata, MaterialCpfCnpjMetadata, MaterialCurrencyMetadata, MaterialDateInputMetadata, MaterialDateRangeMetadata, MaterialDatepickerMetadata, MaterialDatetimeLocalInputMetadata, MaterialDesignConfig, MaterialEmailInputMetadata, MaterialEmailMetadata, MaterialInputMetadata, MaterialMonthInputMetadata, MaterialMultiSelectTreeMetadata, MaterialNumericMetadata, MaterialPasswordMetadata, MaterialPhoneMetadata, MaterialPriceRangeMetadata, MaterialRadioMetadata, MaterialRangeSliderMetadata, MaterialRatingMetadata, MaterialSearchInputMetadata, MaterialSelectMetadata, MaterialSelectionListMetadata, MaterialSliderMetadata, MaterialTextareaMetadata, MaterialTimeInputMetadata, MaterialTimeRangeMetadata, MaterialTimepickerMetadata, MaterialToggleMetadata, MaterialTransferListMetadata, MaterialTreeNode, MaterialTreeSelectMetadata, MaterialUrlInputMetadata, MaterialWeekInputMetadata, MaterialYearInputMetadata, MemoryConfig, MessageTemplate, MessagesConfig, NestedFieldsetLayout, NumberLocaleConfig, OptionDTO, OverlayDecider, OverlayDecision, OverlayDecisionContext, OverlayDecisionMatrix, OverlayPattern, OverlayRange, OverlayRule, OverlayRuleMatch, OverlayThresholds, Page, PageIdentity, PageableRequest, PaginationConfig, PartialFieldMetadata, PdfExportConfig, PerformanceConfig, PersistedPageConfig, PersistedWidgetInstance, PlainObject, PluginConfig, PollingConfig, PriceRangeValue, RangeSliderValue, RenderingConfig, ResizingConfig, ResponsiveConfig, RowAction, RowActionsConfig, RunHooksResult, SchemaIdParams, SelectionConfig, SerializableFieldMetadata, SettingsPanelBridge, SettingsPanelOpenContent, SettingsPanelOpenOptions, SettingsPanelRef, SettingsValueProvider, SortingConfig, SpacingConfig, StateMessagesConfig, SyncConfig, SyncResult, TableActionsConfig, TableAppearanceConfig, TableBehaviorConfig, TableConfig, TableConfigV2 as TableConfigModern, TableConfigState, TableConfigV2, TelemetryEvent, TextTransformApply, TextTransformName, ThemeConfig, ToolbarAction, ToolbarConfig, ToolbarFilterConfig, ToolbarLayoutConfig, ToolbarSettingsConfig, TypographyConfig, ValidationContext, ValidationError, ValidationMessagesConfig, ValidationResult, ValidationRule, ValidatorFunction, ValidatorOptions, VirtualizationConfig, WidgetConnection, WidgetDefinition, WidgetInstance, WidgetPageDefinition };
+export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, ApiConfigStorage, ApiEndpoint, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, ConnectionManagerService, ConsoleLoggerSink, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicGridPageComponent, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG$1 as GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_CATALOG as GLOBAL_ACTION_SPEC_CATALOG, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_ALIAS_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_ALIAS_TOKEN_TO_CONTROL_TYPE, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_TELEMETRY_TRANSPORT, PraxisCore, PraxisGlobalErrorHandler, PraxisIconDirective, PraxisIconPickerComponent, PraxisLoadingInterceptor, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceQuickConnectComponent, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetShellComponent, applyLocalCustomizations$1 as applyLocalCustomizations, applyLocalCustomizations as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildHeaders, buildPageKey, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionUiSchema, getReferencedFieldMetadata, getTextTransformer, isCssTextTransform, isInlineFilterControlType, isRangeValidForFilter, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergeTableConfigs, migrateFormLayoutRule, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, normalizeStart, normalizeUnknownError, notifySuccessHook, parseJsonResponseOrEmpty, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisLoadingDefaults, providePraxisLogging, providePraxisToastGlobalActions, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveHidden, resolveInlineFilterAliasToBaseControlType, resolveInlineFilterControlTypeAlias, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolveSpan, slugify, stripMasksHook, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, trim, uniqueAsyncValidator, urlValidator, withMessage };
+export type { AccessibilityConfig, ActionDefinition, ActionMessagesConfig, AiCapability, AiCapabilityCatalog, AiCapabilityCategory, AiCapabilityCategoryMap, AiConcept, AiConceptPack, AiValueKind, AnimationConfig, AnnouncementConfig, ApiConfigStorageOptions, ApiUrlConfig, ApiUrlEntry, AsyncConfigStorage, BackConfig, BaseMaterialInputMetadata, BatchDeleteOptions, BatchDeleteProgress, BatchDeleteResult, BorderConfig, Breakpoint, BuiltValidators, BulkAction, BulkActionsConfig, CacheAdapter, CacheConfig, CacheEntry, Capability$1 as Capability, CapabilityCatalog$1 as CapabilityCatalog, CapabilityCategory$1 as CapabilityCategory, ColorConfig, ColumnAlign, ColumnDefinition, ColumnHidden, ColumnOffset, ColumnOrder, ColumnSpan, ComponentActionParam, ComponentContextAction, ComponentContextOption, ComponentContextOptionMode, ComponentContextOptionsByPathEntry, ComponentContextPack, ComponentDocMeta, ComponentKeyParams, ComponentMergePatch, ComponentMetadata, ConfigMetadata, ConfigStorage, ConfirmationConfig, ConnectionConfigV1, ConnectionStorage, ContextAction, ContextActionsConfig, BackConfig as CoreBackConfig, CoreFieldMetadata, CrudOperationOptions, CsvExportConfig, CurrencyLocaleConfig, CursorPage, CursorRequest, CustomizationLog, DataConfig, DataTransformation, DataValidationConfig, DateRangePreset, DateRangeValue, DateTimeLocaleConfig, DebounceConfig, DeviceKind, DraggingConfig, Capability as DynamicPageCapability, CapabilityCatalog as DynamicPageCapabilityCatalog, CapabilityCategory as DynamicPageCapabilityCategory, ValueKind as DynamicPageValueKind, ElevationConfig, EmptyAction, EmptyStateConfig, EndpointConfig, EnhancedValidationConfig, ExcelExportConfig, ExcelStylingConfig, ExportConfig, ExportFormat, ExportMessagesConfig, ExportTemplate, FetchWithEtagParams, FetchWithEtagResult, FieldConflict, FieldDefinition, FieldMetadata, FieldModification, FieldOption, FieldSelectorRegistryMap, FieldsetLayout, FilterOptions, FilteringConfig, FormActionButton, FormActionConfirmationEvent, FormActionsLayout, FormApiLayout, FormBehaviorLayout, FormColumn, FormConfig, FormConfigMetadata, FormConfigState, FormCustomActionEvent, FormEntityEvent, FormHook, FormHookContext, FormHookDeclaration, FormHookDeclarationLite, FormHookOutcome, FormHookPreset, FormHookPresetMatch, FormHookStage, FormHookStatus, FormHooksLayout, FormInitializationError, FormLayout, FormLayoutRule, FormMessagesLayout, FormMetadataLayout, FormModeHints, FormOpenMode, FormReadyEvent, FormRow, FormRowLayout, FormRuleTargetType, FormSection, FormSubmitEvent, FormValidationEvent, FormValueChangeEvent, FormattingLocaleConfig, GeneralExportConfig, GetSchemaParams, GlobalActionCatalogEntry, GlobalActionContext, GlobalActionField, GlobalActionFieldOption, GlobalActionFieldType, GlobalActionHandler, GlobalActionHandlerEntry, GlobalActionId, GlobalActionParam, GlobalActionResult, GlobalActionSpec, GlobalActionUiSchema, GlobalAiConfig, GlobalAiEmbeddingConfig, GlobalAiProvider, GlobalAnalyticsService, GlobalApiClient, GlobalCacheConfig, GlobalConfig, GlobalCrudActionDefaults, GlobalCrudConfig, GlobalCrudDefaults, GlobalDialogAction, GlobalDialogAnimation, GlobalDialogAriaRole, GlobalDialogConfig, GlobalDialogConfigEntry, GlobalDialogPosition, GlobalDialogService, GlobalDialogStyles, GlobalDynamicFieldsAsyncSelectConfig, GlobalDynamicFieldsCascadeConfig, GlobalDynamicFieldsConfig, GlobalRouteGuardResolver, GlobalTableConfig, GlobalToastService, GridItemLayout, GridPageDefinition, GridPageDefinitionWithIds, GridWidgetInstance, HookResolver, InlineFilterControlType, InlineRangeDistributionBin, InlineRangeDistributionConfig, InteractionConfig, JsonExportConfig, KeyboardAccessibilityConfig, LazyLoadingConfig, LegacyTableConfig, LoadingConfig, LoadingContext, LoadingPhase$1 as LoadingPhase, LoadingScope, LoadingState, LoadingPhase as LoadingStatePhase, LocalizationConfig, LocateRequest, LoggerConfig, LoggerContext, LoggerEvent, LoggerLevel, LoggerLogOptions, LoggerNormalizedError, LoggerPIIConfig, LoggerSink, LoggerTelemetryPayload, LoggerThrottleConfig, MarginConfig, MaterialAutocompleteMetadata, MaterialButtonMetadata, MaterialButtonToggleMetadata, MaterialCheckboxMetadata, MaterialChipsMetadata, MaterialColorInputMetadata, MaterialColorPickerMetadata, MaterialCpfCnpjMetadata, MaterialCurrencyMetadata, MaterialDateInputMetadata, MaterialDateRangeMetadata, MaterialDatepickerMetadata, MaterialDatetimeLocalInputMetadata, MaterialDesignConfig, MaterialEmailInputMetadata, MaterialEmailMetadata, MaterialInputMetadata, MaterialMonthInputMetadata, MaterialMultiSelectTreeMetadata, MaterialNumericMetadata, MaterialPasswordMetadata, MaterialPhoneMetadata, MaterialPriceRangeMetadata, MaterialRadioMetadata, MaterialRangeSliderMetadata, MaterialRatingMetadata, MaterialSearchInputMetadata, MaterialSelectMetadata, MaterialSelectionListMetadata, MaterialSliderMetadata, MaterialTextareaMetadata, MaterialTimeInputMetadata, MaterialTimeRangeMetadata, MaterialTimeTrackShift, MaterialTimepickerMetadata, MaterialToggleMetadata, MaterialTransferListMetadata, MaterialTreeNode, MaterialTreeSelectMetadata, MaterialUrlInputMetadata, MaterialWeekInputMetadata, MaterialYearInputMetadata, MemoryConfig, MessageTemplate, MessagesConfig, NestedFieldsetLayout, NormalizedError, NumberLocaleConfig, ObservabilityAlert, ObservabilityAlertGroupBy, ObservabilityAlertRule, ObservabilityAlertSeverity, ObservabilityCountBucket, ObservabilityDashboardOptions, ObservabilityIngestInput, ObservabilityMetricsSnapshot, OptionDTO, OverlayDecider, OverlayDecision, OverlayDecisionContext, OverlayDecisionMatrix, OverlayPattern, OverlayRange, OverlayRule, OverlayRuleMatch, OverlayThresholds, Page, PageIdentity, PageableRequest, PaginationConfig, PartialFieldMetadata, PdfExportConfig, PerformanceConfig, PersistedPageConfig, PersistedWidgetInstance, PlainObject, PluginConfig, PollingConfig, PraxisAnalyticsOptions, PraxisAuthContext, PraxisGlobalActionsOptions, PraxisGlobalConfigBootstrapOptions, PraxisLoadingRenderer, PraxisLoggingEnvironment, PraxisLoggingOptions, PraxisToastOptions, PriceRangeValue, RangeSliderInlineTexts, RangeSliderQuickPreset, RangeSliderQuickPresetLabels, RangeSliderValue, RenderingConfig, ResizingConfig, ResolvePresetOptions, ResponsiveConfig, RowAction, RowActionsConfig, RulePropertyDefinition, RulePropertySchema, RulePropertyType, RunHooksResult, SchemaIdParams, SchemaMetaInfo, SchemaViewerContext, SelectionConfig, SerializableFieldMetadata, SettingsPanelBridge, SettingsPanelOpenContent, SettingsPanelOpenOptions, SettingsPanelRef, SettingsValueProvider, SortingConfig, SpacingConfig, StateMessagesConfig, SyncConfig, SyncResult, TableActionsConfig, TableAppearanceConfig, TableBehaviorConfig, TableConfig, TableConfigV2 as TableConfigModern, TableConfigState, TableConfigV2, TableExpansionConfig, TableLocalDataModeConfig, TelemetryEvent, TelemetryLoggerSinkOptions, TelemetryTransport, TextTransformApply, TextTransformName, ThemeConfig, ToolbarAction, ToolbarConfig, ToolbarFilterConfig, ToolbarLayoutConfig, ToolbarSettingsConfig, TypographyConfig, ValidationContext, ValidationError, ValidationMessagesConfig, ValidationResult, ValidationRule, ValidatorFunction, ValidatorOptions, ValueKind$1 as ValueKind, VirtualizationConfig, WidgetConnection, WidgetDefinition, WidgetInstance, WidgetPageDefinition, WidgetPageLayout, WidgetPageOrientation, WidgetShellAction, WidgetShellActionEvent, WidgetShellActionPlacement, WidgetShellConfig, WidgetShellWindowActions };