@praxisui/core 10.0.0-rc.4 → 10.0.0-rc.6

package/types/praxisui-core-schema.d.ts

@@ -0,0 +1,4418 @@
+type OptionSourceType = 'RESOURCE_ENTITY' | 'DISTINCT_DIMENSION' | 'CATEGORICAL_BUCKET' | 'LIGHT_LOOKUP' | 'STATIC_CANONICAL';
+type OptionSourceSearchMode = 'none' | 'starts-with' | 'contains' | 'exact';
+type OptionSourceCachePolicy = 'none' | 'request-scope' | 'session-scope' | 'etag-aware';
+type OptionSourceSelectedReloadPolicy = 'required' | 'supported' | 'unsupported-with-waiver' | 'not-applicable';
+type OptionSourceInvalidSortPolicy = 'reject' | 'ignore' | 'unsupported';
+type LookupOpenDetailMode = 'samePage' | 'newTab' | 'drawer' | 'modal' | 'route';
+type LookupStatusTone = 'success' | 'warning' | 'danger' | 'neutral';
+type LookupFilterFieldType = 'text' | 'enum' | 'date' | 'number' | 'reference';
+type LookupFilterOperator = 'contains' | 'startsWith' | 'equals' | 'in' | 'before' | 'after' | 'between' | 'gt' | 'gte' | 'lt' | 'lte';
+type EntityLookupSelectedLayout = 'card' | 'inline' | 'compact' | 'token';
+type EntityLookupResultLayout = 'list' | 'denseList' | 'table' | 'card';
+type EntityLookupDisplayPreset = 'compact' | 'rich' | 'directory' | 'status' | 'reference' | 'hierarchical';
+type EntityLookupUsage = 'form' | 'filter' | 'table-cell' | 'dashboard' | 'wizard' | 'review';
+type EntityLookupDensity = 'compact' | 'comfortable' | 'rich';
+type EntityLookupDisplayFieldPresentation = 'text' | 'chip' | 'badge' | 'date' | 'currency' | 'metric';
+interface EntityLookupDisplayFieldMetadata {
+    key?: string;
+    propertyPath?: string;
+    label?: string;
+    icon?: string;
+    presentation?: EntityLookupDisplayFieldPresentation | string;
+    tone?: LookupStatusTone | 'info' | string;
+    format?: string;
+}
+interface LookupSelectionPolicyMetadata {
+    selectablePropertyPath?: string;
+    statusPropertyPath?: string;
+    allowedStatuses?: string[];
+    blockedStatuses?: string[];
+    allowRetainInvalidExistingValue?: boolean;
+    disabledReasonTemplate?: string;
+    validationMessageTemplate?: string;
+}
+interface LookupCapabilitiesMetadata {
+    filter?: boolean;
+    byIds?: boolean;
+    detail?: boolean;
+    create?: boolean;
+    edit?: boolean;
+    navigateToDetail?: boolean;
+    multiSelect?: boolean;
+    recent?: boolean;
+    favorites?: boolean;
+    auditSnapshot?: boolean;
+}
+interface LookupDetailMetadata {
+    hrefTemplate?: string;
+    routeTemplate?: string;
+    openDetailMode?: LookupOpenDetailMode;
+    kind?: 'surface' | 'route' | 'href' | string;
+    surfaceId?: string;
+    presentation?: 'modal' | 'drawer' | string;
+    preferredWidget?: string;
+    mode?: 'view' | 'edit' | 'create' | string;
+}
+interface LookupCreateMetadata {
+    hrefTemplate?: string;
+    routeTemplate?: string;
+    openMode?: LookupOpenDetailMode;
+}
+interface LookupFilterDefinitionMetadata {
+    field: string;
+    label?: string;
+    type: LookupFilterFieldType;
+    operators: LookupFilterOperator[];
+    defaultOperator?: LookupFilterOperator;
+    optionsSource?: string;
+    required?: boolean;
+    hidden?: boolean;
+}
+interface LookupSortOptionMetadata {
+    key: string;
+    field: string;
+    direction: 'asc' | 'desc';
+    label?: string;
+}
+type LookupSearchStrategyKind = 'business-code' | 'descriptive-text' | 'normalized-document';
+type LookupSearchInputFormat = 'text' | 'digits';
+/** A server-governed interpretation for a lookup search term. */
+interface LookupSearchStrategyMetadata {
+    key: string;
+    kind: LookupSearchStrategyKind;
+    minSearchChars: number;
+    inputFormat?: LookupSearchInputFormat;
+}
+interface LookupFilteringMetadata {
+    availableFilters?: LookupFilterDefinitionMetadata[];
+    defaultFilters?: Record<string, unknown[]>;
+    sortOptions?: LookupSortOptionMetadata[];
+    defaultSort?: string;
+    quickFilterFields?: string[];
+    searchPlaceholder?: string;
+    searchStrategies?: LookupSearchStrategyMetadata[];
+}
+interface EntityLookupActionsMetadata {
+    showDetail?: boolean;
+    showChange?: boolean;
+    showCopyCode?: boolean;
+    showCopyId?: boolean;
+    showCreate?: boolean;
+    showClear?: boolean;
+}
+interface EntityLookupDisplayMetadata {
+    preset?: EntityLookupDisplayPreset | string;
+    usage?: EntityLookupUsage | string;
+    density?: EntityLookupDensity | string;
+    selectedLayout?: EntityLookupSelectedLayout;
+    resultLayout?: EntityLookupResultLayout;
+    primaryPropertyPath?: string;
+    fields?: EntityLookupDisplayFieldMetadata[];
+    secondaryPropertyPaths?: string[];
+    badgePropertyPaths?: string[];
+    avatarPropertyPath?: string;
+    showCode?: boolean;
+    showDescription?: boolean;
+    showStatus?: boolean;
+    showAvatar?: boolean;
+    showBadges?: boolean;
+    showDisabledReason?: boolean;
+    showResultCount?: boolean;
+    statusLabelMap?: Record<string, string>;
+    statusToneMap?: Record<string, LookupStatusTone>;
+    badgeKeys?: string[];
+    maxVisibleBadges?: number;
+    detailActionLabel?: string;
+    changeActionLabel?: string;
+    copyCodeActionLabel?: string;
+    copyIdActionLabel?: string;
+    createActionLabel?: string;
+    clearActionLabel?: string;
+    actions?: EntityLookupActionsMetadata;
+}
+interface OptionSourceMetadata {
+    key: string;
+    type?: OptionSourceType;
+    resourcePath?: string;
+    filterField?: string;
+    propertyPath?: string;
+    labelPropertyPath?: string;
+    valuePropertyPath?: string;
+    dependsOn?: string[];
+    entityKey?: string;
+    codePropertyPath?: string;
+    descriptionPropertyPaths?: string[];
+    statusPropertyPath?: string;
+    disabledPropertyPath?: string;
+    disabledReasonPropertyPath?: string;
+    searchPropertyPaths?: string[];
+    dependencyFilterMap?: Record<string, string>;
+    selectionPolicy?: LookupSelectionPolicyMetadata;
+    capabilities?: LookupCapabilitiesMetadata;
+    detail?: LookupDetailMetadata;
+    create?: LookupCreateMetadata;
+    display?: EntityLookupDisplayMetadata;
+    filtering?: LookupFilteringMetadata;
+    excludeSelfField?: boolean;
+    searchMode?: OptionSourceSearchMode;
+    pageSize?: number;
+    includeIds?: boolean;
+    cachePolicy?: OptionSourceCachePolicy;
+    selectedReloadPolicy?: OptionSourceSelectedReloadPolicy;
+    invalidSortPolicy?: OptionSourceInvalidSortPolicy;
+}
+
+type JsonLogicPrimitive = string | number | boolean | null;
+interface JsonLogicArray extends Array<JsonLogicValue> {
+}
+interface JsonLogicRecord {
+    [key: string]: JsonLogicValue | undefined;
+}
+type JsonLogicVarReference = string | [path: string] | [path: string, defaultValue: JsonLogicValue];
+interface JsonLogicVarExpression {
+    var: JsonLogicVarReference;
+}
+type JsonLogicArguments = JsonLogicValue | JsonLogicArray;
+interface JsonLogicOperationExpression {
+    [operator: string]: JsonLogicArguments;
+}
+type JsonLogicExpression = JsonLogicPrimitive | JsonLogicVarExpression | JsonLogicOperationExpression;
+type JsonLogicDerivedValueExpression = Exclude<JsonLogicExpression, string>;
+type JsonLogicValue = JsonLogicPrimitive | JsonLogicExpression | JsonLogicArray | JsonLogicRecord;
+
+type PraxisPresentationVisualizationKind = 'line' | 'area' | 'column' | 'comparison' | 'stackedBar' | 'radial' | 'harveyBall' | 'bullet' | 'delta' | 'processFlow';
+type PraxisPresentationVisualizationSurface = 'table-cell' | 'list-item' | 'object-header' | 'card-summary' | 'form-presentation';
+type PraxisPresentationVisualizationSize = 'xs' | 'sm' | 'md' | 'lg' | 'responsive';
+type PraxisPresentationVisualizationTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'critical';
+interface PraxisPresentationVisualizationPoint {
+    label?: string;
+    value: number;
+    tone?: PraxisPresentationVisualizationTone;
+}
+interface PraxisPresentationVisualizationSegment {
+    label?: string;
+    value: number;
+    tone?: PraxisPresentationVisualizationTone;
+}
+interface PraxisPresentationVisualizationThreshold {
+    label?: string;
+    value?: number;
+    min?: number;
+    max?: number;
+    equals?: unknown;
+    tone?: PraxisPresentationVisualizationTone;
+}
+interface PraxisPresentationVisualizationItem {
+    id?: string;
+    label?: string;
+    value?: number;
+    icon?: string;
+    tone?: PraxisPresentationVisualizationTone;
+    state?: string;
+}
+interface PraxisPresentationVisualizationConfig {
+    kind: PraxisPresentationVisualizationKind;
+    surface?: PraxisPresentationVisualizationSurface;
+    size?: PraxisPresentationVisualizationSize;
+    value?: unknown;
+    valueExpr?: JsonLogicExpression | string;
+    valueSuffix?: string;
+    valueSuffixExpr?: JsonLogicExpression | string;
+    compactValue?: boolean;
+    total?: number;
+    totalExpr?: JsonLogicExpression | string;
+    target?: number;
+    targetExpr?: JsonLogicExpression | string;
+    baseline?: number;
+    baselineExpr?: JsonLogicExpression | string;
+    points?: PraxisPresentationVisualizationPoint[];
+    pointsExpr?: JsonLogicExpression | string;
+    segments?: PraxisPresentationVisualizationSegment[];
+    segmentsExpr?: JsonLogicExpression | string;
+    thresholds?: PraxisPresentationVisualizationThreshold[];
+    thresholdsExpr?: JsonLogicExpression | string;
+    items?: PraxisPresentationVisualizationItem[];
+    itemsExpr?: JsonLogicExpression | string;
+    tone?: PraxisPresentationVisualizationTone;
+    toneExpr?: JsonLogicExpression | string;
+    stepLabelWidth?: number | string;
+    stepLabelLineClamp?: number;
+    ariaLabel?: string;
+    ariaLabelExpr?: JsonLogicExpression | string;
+    fallbackText: string;
+    fallbackTextExpr?: JsonLogicExpression | string;
+}
+declare function isPraxisPresentationVisualizationTableSafe(value: PraxisPresentationVisualizationConfig | null | undefined): boolean;
+
+type RichBlockContextScope = 'row' | 'computed' | 'detail' | 'meta' | 'user' | 'tenant';
+interface RichBlockContextConfig {
+    scopes?: RichBlockContextScope[];
+    aliases?: Record<string, string>;
+}
+interface RichBlockRuleSet {
+    visibleWhen?: JsonLogicExpression | null;
+    disabledWhen?: JsonLogicExpression | null;
+    loadWhen?: JsonLogicExpression | null;
+    classWhen?: Array<{
+        className: string;
+        expr: JsonLogicExpression;
+    }>;
+    styleWhen?: Array<{
+        style: Record<string, string | number>;
+        expr: JsonLogicExpression;
+    }>;
+}
+type RichCapabilityMode = 'all' | 'any';
+interface RichBlockBaseNode extends RichBlockRuleSet {
+    id?: string;
+    testId?: string;
+    className?: string;
+    style?: Record<string, string | number>;
+    bindings?: RichBlockContextConfig;
+    requiresCapabilities?: string[];
+    capabilityMode?: RichCapabilityMode;
+}
+interface RichTextNode extends RichBlockBaseNode {
+    type: 'text';
+    text?: string;
+    textExpr?: string;
+}
+interface RichIconNode extends RichBlockBaseNode {
+    type: 'icon';
+    icon: string;
+    ariaLabel?: string;
+}
+interface RichImageNode extends RichBlockBaseNode {
+    type: 'image';
+    src?: string;
+    srcExpr?: string;
+    alt?: string;
+    altExpr?: string;
+    aspectRatio?: RichCardMediaAspectRatio;
+    objectFit?: RichCardMediaObjectFit;
+    width?: string;
+    height?: string;
+}
+interface RichLinkNode extends RichBlockBaseNode {
+    type: 'link';
+    label?: string;
+    labelExpr?: string;
+    href: string;
+    target?: '_blank' | '_self';
+    rel?: string;
+}
+type RichSemanticTone = 'primary' | 'secondary' | 'tertiary' | 'info' | 'success' | 'warning' | 'danger' | 'error' | 'neutral';
+interface RichBadgeNode extends RichBlockBaseNode {
+    type: 'badge';
+    label?: string;
+    labelExpr?: string;
+    icon?: string;
+    tone?: RichSemanticTone;
+}
+interface RichAvatarNode extends RichBlockBaseNode {
+    type: 'avatar';
+    name?: string;
+    nameExpr?: string;
+    imageSrc?: string;
+    imageSrcExpr?: string;
+    initials?: string;
+    initialsExpr?: string;
+}
+interface RichMetricNode extends RichBlockBaseNode {
+    type: 'metric';
+    label: string;
+    valueExpr: string;
+    captionExpr?: string;
+    icon?: string;
+    format?: string;
+}
+interface RichProgressNode extends RichBlockBaseNode {
+    type: 'progress';
+    value?: number;
+    valueExpr?: string;
+    max?: number;
+    label?: string;
+    labelExpr?: string;
+    showPercent?: boolean;
+}
+interface RichActionRef {
+    actionId: string;
+    payload?: unknown;
+    payloadExpr?: string;
+    availabilityExpr?: string;
+    confirmMessage?: string;
+}
+interface RichActionButtonNode extends RichBlockBaseNode {
+    type: 'actionButton';
+    label?: string;
+    labelExpr?: string;
+    icon?: string;
+    variant?: 'basic' | 'raised' | 'stroked' | 'flat';
+    color?: 'basic' | 'primary' | 'accent' | 'warn';
+    action: RichActionRef;
+}
+interface RichMicroVisualizationNode extends RichBlockBaseNode {
+    type: 'microVisualization';
+    visualization?: PraxisPresentationVisualizationConfig;
+    visualizationExpr?: string;
+    kind?: string;
+    pointsExpr?: string;
+    valueExpr?: string;
+    targetExpr?: string;
+}
+type RichPresenterNode = RichTextNode | RichIconNode | RichImageNode | RichLinkNode | RichBadgeNode | RichAvatarNode | RichMetricNode | RichProgressNode | RichActionButtonNode | RichMicroVisualizationNode;
+type RichComposeLayout = 'flex' | 'grid';
+type RichComposeAlignItems = 'stretch' | 'start' | 'center' | 'end';
+interface RichComposeNode extends RichBlockBaseNode {
+    type: 'compose';
+    layout?: RichComposeLayout;
+    direction?: 'row' | 'column';
+    gap?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    wrap?: boolean;
+    columns?: number | 'auto-fit' | 'auto-fill';
+    minColumnWidth?: string;
+    alignItems?: RichComposeAlignItems;
+    items: RichBlockNode[];
+}
+type RichCardVariant = 'plain' | 'outlined' | 'elevated' | 'filled' | 'transparent' | 'unstyled';
+type RichCardTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+type RichCardSize = 'sm' | 'md' | 'lg';
+type RichCardDensity = 'compact' | 'comfortable';
+type RichCardOrientation = 'vertical' | 'horizontal';
+type RichCardMediaKind = 'image' | 'video' | 'icon' | 'avatar' | 'telemetry' | 'lottie';
+interface RichCardMediaTelemetry {
+    variant?: 'radar' | 'pulse' | 'wave' | 'signal';
+    speed?: 'slow' | 'normal' | 'fast';
+    color?: string;
+    interactive?: boolean;
+}
+type RichCardMediaPlacement = 'top' | 'leading' | 'trailing' | 'background';
+type RichCardMediaObjectFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+type RichCardMediaAspectRatio = '16:9' | '4:3' | '1:1' | '21:9' | 'auto' | string;
+interface RichCardMedia {
+    kind: RichCardMediaKind;
+    src?: string;
+    srcExpr?: string;
+    alt?: string;
+    altExpr?: string;
+    icon?: string;
+    label?: string;
+    labelExpr?: string;
+    placement?: RichCardMediaPlacement;
+    aspectRatio?: RichCardMediaAspectRatio;
+    objectFit?: RichCardMediaObjectFit;
+    telemetry?: RichCardMediaTelemetry;
+    animationSrc?: string;
+    verticalAlign?: 'center' | 'top' | 'bottom' | 'stretch';
+}
+type RichCardInteractionMode = 'none' | 'action' | 'selectable';
+interface RichCardInteraction {
+    mode: RichCardInteractionMode;
+    action?: RichActionRef;
+    selected?: boolean;
+    selectedExpr?: string;
+}
+interface RichCardAccessibility {
+    role?: 'article' | 'group' | 'button';
+    ariaLabel?: string;
+    ariaLabelExpr?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+}
+/** Semantic page opening. Navigation remains links; commands remain host-mediated actions. */
+interface RichPageHeaderNode extends RichBlockBaseNode {
+    type: 'pageHeader';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    /** Document outline level, independent of visual size. Defaults to 1. */
+    headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
+    size?: 'sm' | 'md' | 'lg';
+    identity?: RichIconNode | RichAvatarNode | RichImageNode;
+    /** Ancestors only. The resolved title is the non-link current item. */
+    breadcrumbs?: RichLinkNode[];
+    primaryAction?: RichActionButtonNode;
+    secondaryActions?: RichActionButtonNode[];
+    overflowActions?: RichActionButtonNode[];
+    relatedLinks?: RichLinkNode[];
+}
+interface RichCardNode extends RichBlockBaseNode {
+    type: 'card';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    content: Array<RichPresenterNode | RichComposeNode>;
+    media?: RichCardMedia;
+    headerAction?: RichActionButtonNode;
+    header?: RichBlockNode[];
+    body?: RichBlockNode[];
+    footer?: RichBlockNode[];
+    actions?: RichActionButtonNode[];
+    aside?: RichBlockNode[];
+    variant?: RichCardVariant;
+    tone?: RichCardTone;
+    size?: RichCardSize;
+    density?: RichCardDensity;
+    orientation?: RichCardOrientation;
+    loading?: boolean;
+    loadingExpr?: string;
+    active?: boolean;
+    activeExpr?: string;
+    interaction?: RichCardInteraction;
+    accessibility?: RichCardAccessibility;
+}
+interface RichCalloutNode extends RichBlockBaseNode {
+    type: 'callout';
+    tone?: 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+    icon?: string;
+    title?: string;
+    titleExpr?: string;
+    message?: string;
+    messageExpr?: string;
+    actions?: RichActionButtonNode[];
+}
+type RichCtaGroupLayout = 'stacked' | 'split';
+interface RichCtaGroupNode extends RichBlockBaseNode {
+    type: 'ctaGroup';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    message?: string;
+    messageExpr?: string;
+    layout?: RichCtaGroupLayout;
+    actions: RichActionButtonNode[];
+}
+interface RichKeyValueItem {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    value?: string;
+    valueExpr?: string;
+    badge?: string;
+    badgeExpr?: string;
+    icon?: string;
+}
+interface RichKeyValueListNode extends RichBlockBaseNode {
+    type: 'keyValueList';
+    title?: string;
+    titleExpr?: string;
+    layout?: 'stacked' | 'inline';
+    items: RichKeyValueItem[];
+}
+type RichPropertySheetColumns = 1 | 2;
+type RichPropertySheetTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+interface RichPropertySheetItem {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    value?: string;
+    valueExpr?: string;
+    hint?: string;
+    hintExpr?: string;
+    icon?: string;
+    tone?: RichPropertySheetTone;
+}
+interface RichPropertySheetNode extends RichBlockBaseNode {
+    type: 'propertySheet';
+    title?: string;
+    titleExpr?: string;
+    columns?: RichPropertySheetColumns;
+    /**
+     * Caminho canônico do recurso para resolução de schema via /schemas/filtered.
+     * Ex: 'human-resources/funcionarios'
+     */
+    resourcePath?: string;
+    /**
+     * Referência OpenAPI ao schema de componentes.
+     * Ex: '#/components/schemas/FuncionarioDTO'
+     */
+    schemaRef?: string;
+    /**
+     * Filtro opcional por grupo canônico (x-ui group).
+     * Ex: 'Identificação', 'Profissional'
+     */
+    group?: string;
+    /**
+     * Caminho para resolução dos dados no contexto (ex: 'hero', 'funcionario').
+     * Se omitido, utiliza a raiz do contexto de avaliação.
+     */
+    dataContextPath?: string;
+    /**
+     * Itens estáticos ou overrides de campos do schema.
+     * Opcional quando resourcePath, schemaRef ou dataContextPath for informado.
+     */
+    items?: RichPropertySheetItem[];
+}
+type RichStatGroupLayout = 'stacked' | 'inline' | 'grid';
+type RichStatTone = RichSemanticTone;
+type RichStatGroupHeaderSpacing = 'tight' | 'normal' | 'relaxed';
+type RichStatGroupTileLayout = 'classic' | 'tile' | 'split';
+interface RichStatItemProgress {
+    value?: number;
+    valueExpr?: string;
+    max?: number;
+    showPercent?: boolean;
+    variant?: 'bar' | 'ring';
+    tone?: RichStatTone;
+}
+interface RichStatItem {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    value?: string;
+    valueExpr?: string;
+    caption?: string;
+    captionExpr?: string;
+    icon?: string;
+    tone?: RichStatTone;
+    progress?: RichStatItemProgress;
+    action?: RichActionRef;
+    tileLayout?: RichStatGroupTileLayout;
+}
+interface RichStatGroupNode extends RichBlockBaseNode {
+    type: 'statGroup';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    headerSpacing?: RichStatGroupHeaderSpacing;
+    tileLayout?: RichStatGroupTileLayout;
+    layout?: RichStatGroupLayout;
+    items: RichStatItem[];
+}
+type RichTabsAppearance = 'underline' | 'pills';
+interface RichTabsItem extends RichBlockRuleSet {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    icon?: string;
+    badge?: string;
+    badgeExpr?: string;
+    requiresCapabilities?: string[];
+    capabilityMode?: RichCapabilityMode;
+    content: RichBlockNode[];
+}
+interface RichTabsNode extends RichBlockBaseNode {
+    type: 'tabs';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    appearance?: RichTabsAppearance;
+    defaultTabId?: string;
+    wrap?: boolean;
+    scrollable?: boolean;
+    items: RichTabsItem[];
+}
+interface RichEmptyStateNode extends RichBlockBaseNode {
+    type: 'emptyState';
+    icon?: string;
+    title?: string;
+    titleExpr?: string;
+    message?: string;
+    messageExpr?: string;
+    actions?: RichActionButtonNode[];
+}
+interface RichRecordSummaryField {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    value?: string;
+    valueExpr?: string;
+}
+interface RichRecordSummaryNode extends RichBlockBaseNode {
+    type: 'recordSummary';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    meta?: string;
+    metaExpr?: string;
+    fields: RichRecordSummaryField[];
+    actions?: RichActionButtonNode[];
+}
+type RichLookupResultStatus = 'idle' | 'resolved' | 'empty' | 'error';
+interface RichLookupResultField {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    value?: string;
+    valueExpr?: string;
+    hint?: string;
+    hintExpr?: string;
+}
+interface RichLookupResultNode extends RichBlockBaseNode {
+    type: 'lookupResult';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    status?: RichLookupResultStatus;
+    statusExpr?: string;
+    emptyText?: string;
+    emptyTextExpr?: string;
+    errorText?: string;
+    errorTextExpr?: string;
+    meta?: string;
+    metaExpr?: string;
+    fields: RichLookupResultField[];
+    actions?: RichActionButtonNode[];
+}
+interface RichLookupCardNode extends RichBlockBaseNode {
+    type: 'lookupCard';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    icon?: string;
+    status?: RichLookupResultStatus;
+    statusExpr?: string;
+    emptyText?: string;
+    emptyTextExpr?: string;
+    errorText?: string;
+    errorTextExpr?: string;
+    meta?: string;
+    metaExpr?: string;
+    ctaLabel?: string;
+    ctaLabelExpr?: string;
+    ctaIcon?: string;
+    variant?: 'basic' | 'raised' | 'stroked' | 'flat';
+    color?: 'basic' | 'primary' | 'accent' | 'warn';
+    action: RichActionRef;
+    fields: RichLookupResultField[];
+    secondaryActions?: RichActionButtonNode[];
+}
+interface RichRelatedRecordNode extends RichBlockBaseNode {
+    type: 'relatedRecord';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    relationLabel?: string;
+    relationLabelExpr?: string;
+    icon?: string;
+    meta?: string;
+    metaExpr?: string;
+    ctaLabel?: string;
+    ctaLabelExpr?: string;
+    ctaIcon?: string;
+    variant?: 'basic' | 'raised' | 'stroked' | 'flat';
+    color?: 'basic' | 'primary' | 'accent' | 'warn';
+    action?: RichActionRef;
+    fields: RichLookupResultField[];
+    secondaryActions?: RichActionButtonNode[];
+}
+type RichActionCardCtaPlacement = 'bottom' | 'inline' | 'trailing';
+type RichActionCardCtaVariant = 'elevated' | 'stroked' | 'flat' | 'tonal' | 'raised';
+interface RichActionCardNode extends RichBlockBaseNode {
+    type: 'actionCard';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    message?: string;
+    messageExpr?: string;
+    icon?: string;
+    meta?: string;
+    metaExpr?: string;
+    ctaLabel?: string;
+    ctaLabelExpr?: string;
+    ctaIcon?: string;
+    ctaPlacement?: RichActionCardCtaPlacement;
+    ctaVariant?: RichActionCardCtaVariant;
+    variant?: 'basic' | 'raised' | 'stroked' | 'flat' | 'unstyled';
+    color?: 'basic' | 'primary' | 'accent' | 'warn';
+    action: RichActionRef;
+    secondaryActions?: RichActionButtonNode[];
+}
+type RichDecisionGovernanceStatus = 'draft' | 'simulated' | 'approved' | 'published' | 'superseded' | 'reverted';
+type RichDecisionRisk = 'low' | 'medium' | 'high' | 'critical';
+interface RichDecisionPackageEvidence {
+    id?: string;
+    label?: string;
+    labelExpr?: string;
+    source?: string;
+    sourceExpr?: string;
+}
+interface RichDecisionPackageNode extends RichBlockBaseNode {
+    type: 'decisionPackage';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    summary?: string;
+    summaryExpr?: string;
+    status?: RichDecisionGovernanceStatus;
+    statusExpr?: string;
+    owner?: string;
+    ownerExpr?: string;
+    policySource?: string;
+    policySourceExpr?: string;
+    version?: string;
+    versionExpr?: string;
+    confidence?: number;
+    confidenceExpr?: string;
+    risk?: RichDecisionRisk;
+    riskExpr?: string;
+    lastReviewed?: string;
+    lastReviewedExpr?: string;
+    supersedes?: string;
+    supersedesExpr?: string;
+    evidence?: RichDecisionPackageEvidence[];
+    primaryAction?: RichActionButtonNode;
+    secondaryActions?: RichActionButtonNode[];
+}
+interface RichFormLauncherNode extends RichBlockBaseNode {
+    type: 'formLauncher';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    description?: string;
+    descriptionExpr?: string;
+    icon?: string;
+    formId?: string;
+    ctaLabel?: string;
+    ctaLabelExpr?: string;
+    ctaIcon?: string;
+    variant?: 'basic' | 'raised' | 'stroked' | 'flat';
+    color?: 'basic' | 'primary' | 'accent' | 'warn';
+    action: RichActionRef;
+    secondaryActions?: RichActionButtonNode[];
+}
+interface RichDynamicFormNode extends RichBlockBaseNode {
+    type: 'dynamicForm';
+    /** Caminho do recurso canônico. Ex: 'human-resources/funcionarios' */
+    resourcePath: string;
+    /** Modo do formulário: visualização/apresentação ('view') ou edição ('edit'). Padrão: 'view'. */
+    mode?: 'view' | 'edit';
+    /** Apresentação governada para dossiês e painéis editoriais sem caixas de input. Padrão: true em view mode. */
+    presentationMode?: boolean;
+    /** Filtro de grupos canônicos a serem renderizados. */
+    groupFilter?: string[];
+    /** Caminho de vinculação dos dados no contexto do documento (ex: 'hero'). */
+    dataBinding?: string;
+    /** Identificador opcional do formulário. */
+    formId?: string;
+}
+interface RichCollapsibleCardNode extends RichBlockBaseNode {
+    type: 'collapsibleCard';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    icon?: string;
+    defaultExpanded?: boolean;
+    actions?: RichActionButtonNode[];
+    content: RichBlockNode[];
+}
+interface RichDisclosureNode extends RichBlockBaseNode {
+    type: 'disclosure';
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    icon?: string;
+    appearance?: 'plain' | 'card';
+    defaultExpanded?: boolean;
+    actions?: RichActionButtonNode[];
+    content: RichBlockNode[];
+}
+interface RichAccordionItem {
+    id?: string;
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    icon?: string;
+    defaultExpanded?: boolean;
+    actions?: RichActionButtonNode[];
+    content: RichBlockNode[];
+}
+interface RichAccordionNode extends RichBlockBaseNode {
+    type: 'accordion';
+    title?: string;
+    titleExpr?: string;
+    multi?: boolean;
+    items: RichAccordionItem[];
+}
+interface RichMediaBlockNode extends RichBlockBaseNode {
+    type: 'mediaBlock';
+    avatar?: RichAvatarNode;
+    title?: RichTextNode;
+    subtitle?: RichTextNode;
+    meta?: RichComposeNode;
+    trailing?: RichBlockNode[];
+}
+interface RichTimelineItem {
+    id?: string;
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    meta?: string;
+    metaExpr?: string;
+    opposite?: string;
+    oppositeExpr?: string;
+    icon?: string;
+    iconExpr?: string;
+    badge?: string;
+    badgeExpr?: string;
+    markerColor?: RichTimelineColor;
+    markerStyle?: RichTimelineMarkerStyle;
+    connectorColor?: RichTimelineColor;
+    connectorVariant?: RichTimelineConnectorVariant;
+    action?: RichActionRef;
+}
+type RichTimelinePosition = 'left' | 'right' | 'alternate' | 'alternate-reverse';
+type RichTimelineOrientation = 'vertical' | 'horizontal';
+type RichTimelineOrder = 'normal' | 'reverse';
+type RichTimelineConnectorVariant = 'solid' | 'dashed' | 'none';
+type RichTimelineMarkerVariant = 'dot' | 'icon' | 'number';
+type RichTimelineMarkerStyle = 'filled' | 'outlined';
+type RichTimelineColor = RichSemanticTone;
+type RichTimelineEmphasis = 'subtle' | 'standard' | 'strong' | 'hero';
+type RichTimelineDensity = 'compact' | 'comfortable' | 'spacious';
+type RichTimelineTextAppearance = 'default' | 'prominent' | 'eyebrow' | 'label';
+interface RichTimelineNode extends RichBlockBaseNode {
+    type: 'timeline';
+    title?: string;
+    titleExpr?: string;
+    emptyText?: string;
+    orientation?: RichTimelineOrientation;
+    order?: RichTimelineOrder;
+    position?: RichTimelinePosition;
+    connectorVariant?: RichTimelineConnectorVariant;
+    connectorColor?: RichTimelineColor;
+    markerVariant?: RichTimelineMarkerVariant;
+    markerColor?: RichTimelineColor;
+    markerStyle?: RichTimelineMarkerStyle;
+    emphasis?: RichTimelineEmphasis;
+    density?: RichTimelineDensity;
+    textAppearance?: RichTimelineTextAppearance;
+    items: RichTimelineItem[];
+}
+type CorePresetKind = 'surface-open' | 'widget-page-layout' | 'widget-page-theme' | 'editorial-theme' | 'editorial-compliance' | 'editorial-solution' | 'rich-block';
+interface CorePresetRef {
+    kind: CorePresetKind;
+    namespace: string;
+    presetId: string;
+    version?: string;
+}
+interface RichPresetReferenceNode extends RichBlockBaseNode {
+    type: 'preset';
+    ref: CorePresetRef & {
+        kind: 'rich-block';
+    };
+    inputs?: Record<string, unknown>;
+}
+type RichPrimitiveNode = RichPresenterNode | RichComposeNode | RichCardNode | RichPageHeaderNode | RichCalloutNode | RichCtaGroupNode | RichKeyValueListNode | RichPropertySheetNode | RichDynamicFormNode | RichStatGroupNode | RichTabsNode | RichEmptyStateNode | RichRecordSummaryNode | RichLookupResultNode | RichLookupCardNode | RichRelatedRecordNode | RichActionCardNode | RichDecisionPackageNode | RichFormLauncherNode | RichCollapsibleCardNode | RichDisclosureNode | RichAccordionNode | RichMediaBlockNode | RichTimelineNode;
+type RichBlockNode = RichPrimitiveNode | RichPresetReferenceNode;
+interface RichContentDocument {
+    kind: 'praxis.rich-content';
+    version: '1.0.0';
+    context?: RichBlockContextConfig;
+    nodes: RichBlockNode[];
+}
+
+interface GlobalActionRef {
+    actionId: string;
+    payload?: any;
+    payloadExpr?: string;
+    meta?: {
+        label?: string;
+        icon?: string;
+        emitLocal?: boolean;
+        confirmation?: any;
+        [key: string]: any;
+    };
+}
+
+type PraxisExportFormat = 'excel' | 'pdf' | 'csv' | 'json' | 'print';
+type PraxisExportScope = 'auto' | 'selected' | 'filtered' | 'currentPage' | 'all';
+
+interface PraxisRuntimeGlobalActionEffect {
+    id?: string;
+    kind: 'global-action';
+    globalAction: GlobalActionRef;
+}
+
+/**
+ * Contratos compartilhados de discovery semantico consumidos pelo runtime Angular.
+ *
+ * `resourcePath` continua sendo o endereco operacional do recurso.
+ * `resourceKey` representa a identidade semantica estavel devolvida pelo backend para
+ * surfaces, actions e capabilities.
+ *
+ * O runtime usa `resourceKey` para preservar contexto semantico e gerar ids estaveis de
+ * abertura, enquanto `resourcePath`, `path`, `method` e `schemaUrl` seguem responsaveis pelo
+ * comportamento operacional.
+ */
+
+interface ResourceAvailabilityDecision {
+    allowed: boolean;
+    reason?: string | null;
+    metadata?: Record<string, any>;
+}
+type ResourceSurfaceKind = 'FORM' | 'PARTIAL_FORM' | 'VIEW' | 'READ_PROJECTION';
+type ResourceSurfaceScope = 'COLLECTION' | 'ITEM';
+type ResourceSurfaceResponseCardinality = 'OBJECT' | 'COLLECTION' | 'PAGE' | 'VOID' | 'UNKNOWN';
+type RelatedResourceChildOperation = 'FILTER' | 'LIST' | 'CREATE' | 'UPDATE' | 'DELETE' | 'DUPLICATE_DRAFT';
+interface RelatedResourceSurface {
+    parentResourceKey: string;
+    parentIdPathVariable: string;
+    childResourceKey: string;
+    childResourcePath: string;
+    childParentField: string;
+    selectable: boolean;
+    selectionKeyField: string;
+    childOperations: RelatedResourceChildOperation[];
+}
+interface ResourceSurfaceCatalogItem {
+    id: string;
+    resourceKey: string;
+    kind: ResourceSurfaceKind;
+    scope: ResourceSurfaceScope;
+    title: string;
+    description?: string | null;
+    intent?: string | null;
+    operationId: string;
+    path: string;
+    method: string;
+    schemaId: string;
+    schemaUrl: string;
+    responseCardinality?: ResourceSurfaceResponseCardinality | null;
+    availability: ResourceAvailabilityDecision;
+    order: number;
+    tags: string[];
+    relatedResource?: RelatedResourceSurface | null;
+}
+
+type FieldPresentationTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+type FieldPresentationAppearance = 'plain' | 'soft' | 'outlined' | 'filled';
+type FieldPresenterKind = 'text' | 'badge' | 'chip' | 'status' | 'iconValue' | 'progress' | 'rating' | 'microVisualization';
+interface FieldPresentationInteractions {
+    /** Allows readonly surfaces to expose a copy affordance without changing the field value. */
+    copy?: boolean;
+    /** Allows readonly surfaces to expose contextual detail expansion. */
+    details?: boolean;
+    /** Allows readonly surfaces to expose inline expansion for long values. */
+    expand?: boolean;
+    /** Allows readonly surfaces to expose a link affordance when the value is navigable. */
+    link?: boolean;
+}
+interface FieldPresentationConfig {
+    /** Semantic display strategy for readonly/presentation surfaces. */
+    presenter?: FieldPresenterKind;
+    /** Alias accepted for schema authors that describe the semantic display as a variant. */
+    variant?: FieldPresenterKind;
+    /** Semantic tone mapped by consumers to theme tokens. */
+    tone?: FieldPresentationTone;
+    /** Material Symbols icon name, without arbitrary HTML. */
+    icon?: string;
+    /** Optional semantic label for status/chip/badge presentations. */
+    label?: string;
+    /** Optional secondary marker rendered by presentation-capable consumers. */
+    badge?: string;
+    /** Optional tooltip text for the presentation wrapper. */
+    tooltip?: string;
+    /** Optional readonly prefix rendered next to the displayed value without changing the raw value. */
+    prefix?: string;
+    /** Optional readonly suffix rendered next to the displayed value without changing the raw value. */
+    suffix?: string;
+    /** Optional icon override when the field resolves to a truthy boolean state. */
+    iconTrue?: string;
+    /** Optional icon override when the field resolves to a falsy boolean state. */
+    iconFalse?: string;
+    /** Optional semantic tone when the field resolves to a truthy boolean state. */
+    toneTrue?: FieldPresentationTone;
+    /** Optional semantic tone when the field resolves to a falsy boolean state. */
+    toneFalse?: FieldPresentationTone;
+    /** Optional display label when the field resolves to a truthy boolean state. */
+    labelTrue?: string;
+    /** Optional display label when the field resolves to a falsy boolean state. */
+    labelFalse?: string;
+    /** Visual density/emphasis strategy mapped by consumers to theme tokens. */
+    appearance?: FieldPresentationAppearance;
+    /** Optional formatter override for the presentation surface only. */
+    valuePresentation?: ValuePresentationConfig;
+    /** Renderer-neutral micro visualization metadata for compact presentation surfaces. */
+    visualization?: PraxisPresentationVisualizationConfig;
+    /** Safe readonly affordances. No commands or mutations are executed from this contract. */
+    interactions?: FieldPresentationInteractions;
+}
+interface FieldPresentationRule {
+    /** Json Logic guard evaluated against the presentation context. */
+    when: JsonLogicExpression;
+    /** Semantic presentation state merged when the guard is truthy. */
+    set?: FieldPresentationConfig;
+    /** Alias for `set`, useful for rule-builder terminology. */
+    effect?: FieldPresentationConfig;
+}
+
+interface TableTooltipConfig {
+    text?: string;
+    position?: 'top' | 'right' | 'bottom' | 'left' | 'above' | 'below' | 'before' | 'after';
+    bgColor?: string;
+    delayMs?: number;
+}
+/**
+ * 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;
+    /** Permitir ordenação */
+    sortable?: boolean;
+    /** Permitir filtragem */
+    filterable?: boolean;
+    /** Permitir redimensionamento */
+    resizable?: boolean;
+    /** Coluna fixa (sticky). true/"start" fixa no início; "end" fixa no fim */
+    sticky?: boolean | 'start' | 'end';
+    /** Alinhamento do conteúdo */
+    align?: 'left' | 'center' | 'right';
+    /** Ordem de exibição */
+    order?: number;
+    /** Campo do backend usado para ordenação (quando diferente de field) */
+    sortField?: string;
+    /** Estilo CSS personalizado */
+    style?: string;
+    /** Estilo CSS do cabeçalho */
+    headerStyle?: string;
+    /** Classe CSS personalizada */
+    cssClass?: string;
+    /** Classe CSS do cabeçalho */
+    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: JsonLogicDerivedValueExpression;
+        /** 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?: {
+        /** Tipo calculado por expressão (tem precedência sobre o tipo estático) */
+        typeExpr?: string | {
+            expr: string;
+        };
+        /** Tipo do renderizador */
+        type: 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'avatar' | 'toggle' | 'menu' | 'rating' | 'microVisualization' | 'html' | 'compose';
+        /** Tooltip associado ao renderer efetivo da célula. */
+        tooltip?: TableTooltipConfig;
+        /** Configuração de ícone (Material/SVG por nome) */
+        icon?: {
+            /** Nome fixo do ícone (ex.: 'check_circle') */
+            name?: string;
+            /** Campo do row que contém o nome do ícone */
+            nameField?: string;
+            /** Texto fixo exibido ao lado do icone */
+            text?: string;
+            /** Campo usado como texto exibido ao lado do icone */
+            textField?: string;
+            /** Cor do ícone (primary/accent/warn ou CSS color) */
+            color?: string;
+            /** Tamanho em px (opcional) */
+            size?: number;
+            /** Label acessível (fixo) */
+            ariaLabel?: string;
+            /** Prefixo visual aplicado ao texto do renderer sem alterar o valor bruto. */
+            prefix?: string;
+            /** Sufixo visual aplicado ao texto do renderer sem alterar o valor bruto. */
+            suffix?: string;
+        };
+        /** Configuração de imagem */
+        image?: {
+            /** URL fixa da imagem */
+            src?: string;
+            /** Campo do row com a URL da imagem */
+            srcField?: string;
+            /** Texto alternativo fixo */
+            alt?: string;
+            /** Campo do row com ALT */
+            altField?: string;
+            /** Dimensões */
+            width?: number;
+            height?: number;
+            /** Forma de recorte */
+            shape?: 'square' | 'rounded' | 'circle';
+            /** Ajuste do objeto */
+            fit?: 'cover' | 'contain';
+            /** Lazy loading */
+            lazy?: boolean;
+        };
+        /** Configuração de badge */
+        badge?: {
+            /** Texto fixo */
+            text?: string;
+            /** Campo do row com texto */
+            textField?: string;
+            /** Cor do badge (primary/accent/warn ou CSS) */
+            color?: string;
+            /** Variante visual */
+            variant?: 'filled' | 'outlined' | 'soft' | 'plain';
+            /** Ícone opcional dentro do badge */
+            icon?: string;
+            /** Tooltip opcional associado ao indicador visual */
+            tooltip?: TableTooltipConfig;
+        };
+        /** 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?: JsonLogicExpression | null;
+            action?: {
+                id: string;
+                payloadExpr?: string;
+            };
+        };
+        /** Chip (etiqueta leve) */
+        chip?: {
+            text?: string;
+            textField?: string;
+            color?: string;
+            icon?: string;
+            variant?: 'filled' | 'outlined' | 'soft' | 'plain';
+            /** Tooltip opcional associado ao chip */
+            tooltip?: TableTooltipConfig;
+        };
+        /** Barra de progresso leve */
+        progress?: {
+            valueExpr: string;
+            color?: string;
+            showLabel?: boolean;
+        };
+        /** Avaliação por estrelas padronizada para leitura em tabelas. */
+        rating?: {
+            valueExpr?: string;
+            max?: number;
+            color?: string;
+            outlineColor?: string;
+            size?: 'small' | 'medium' | 'large';
+            ariaLabel?: string;
+        };
+        microVisualization?: {
+            visualization: PraxisPresentationVisualizationConfig;
+        };
+        /** Avatar (imagem ou iniciais) */
+        avatar?: {
+            src?: string;
+            srcField?: string;
+            alt?: string;
+            altField?: string;
+            initialsField?: string;
+            initialsExpr?: string;
+            shape?: 'square' | 'rounded' | 'circle';
+            size?: number;
+            backgroundColor?: string;
+            textColor?: string;
+        };
+        /** Alternância (toggle) com ação */
+        toggle?: {
+            stateExpr: string;
+            disabledCondition?: JsonLogicExpression | null;
+            action?: {
+                id: string;
+                payloadExpr?: string;
+            };
+            ariaLabel?: string;
+        };
+        /** Menu de ações
+         * itemsExpr → Array<{ label: string; icon?: string; id: string; payloadExpr?: string; visibleCondition?: JsonLogicExpression | null }> */
+        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: 'value';
+                field?: string;
+                textField?: string;
+                valueField?: string;
+                text?: string;
+                emphasis?: 'strong' | 'subtle';
+            } | {
+                type: 'icon';
+                icon?: {
+                    name?: string;
+                    nameField?: string;
+                    text?: string;
+                    textField?: string;
+                    color?: string;
+                    size?: number;
+                    ariaLabel?: string;
+                    prefix?: string;
+                    suffix?: 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' | 'plain';
+                    icon?: string;
+                    tooltip?: TableTooltipConfig;
+                };
+            } | {
+                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?: JsonLogicExpression | null;
+                    action?: {
+                        id: string;
+                        payloadExpr?: string;
+                    };
+                };
+            } | {
+                type: 'chip';
+                chip?: {
+                    text?: string;
+                    textField?: string;
+                    color?: string;
+                    icon?: string;
+                    variant?: 'filled' | 'outlined' | 'soft' | 'plain';
+                    tooltip?: TableTooltipConfig;
+                };
+            } | {
+                type: 'progress';
+                progress?: {
+                    valueExpr: string;
+                    color?: string;
+                    showLabel?: boolean;
+                };
+            } | {
+                type: 'avatar';
+                avatar?: {
+                    src?: string;
+                    srcField?: string;
+                    alt?: string;
+                    altField?: string;
+                    initialsField?: string;
+                    initialsExpr?: string;
+                    shape?: 'square' | 'rounded' | 'circle';
+                    size?: number;
+                    backgroundColor?: string;
+                    textColor?: string;
+                };
+            } | {
+                type: 'toggle';
+                toggle?: {
+                    stateExpr: string;
+                    disabledCondition?: JsonLogicExpression | null;
+                    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;
+                };
+            } | {
+                type: 'microVisualization';
+                microVisualization?: {
+                    visualization: PraxisPresentationVisualizationConfig;
+                };
+            } | {
+                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<{
+        /** Identificador estável usado para reconciliação e deduplicação de regras authoradas. */
+        id?: string;
+        condition: JsonLogicExpression | null;
+        /** Referencia semantica versionada; a classe CSS correspondente e privada do runtime. */
+        surfacePresetRef?: {
+            id: string;
+            catalogVersion: string;
+        };
+        renderer?: Partial<ColumnDefinition['renderer']>;
+        /** Tooltip condicional aplicado quando a regra vencer. */
+        tooltip?: TableTooltipConfig;
+        /** Efeitos visuais canonicos que podem produzir renderer, tooltip ou animacao. */
+        effects?: Array<Record<string, unknown>>;
+        description?: string;
+        enabled?: boolean;
+    }>;
+    /**
+     * Regras de estilo condicionais por coluna (experimental)
+     * Cada regra contém uma expressão canônica em `condition` e o efeito visual a aplicar.
+     */
+    conditionalStyles?: Array<{
+        /** Identificador estável usado para reconciliação e deduplicação de regras authoradas. */
+        id?: string;
+        condition: JsonLogicExpression | null;
+        /** Efeitos visuais canonicos produzidos pelo editor de regras da Table. */
+        effects?: Array<Record<string, unknown>>;
+        cssClass?: string;
+        style?: {
+            [key: string]: string;
+        };
+        tooltip?: Record<string, unknown>;
+        description?: string;
+    }>;
+    /** Estado serializado do construtor visual de regras (round‑trip) */
+    _styleRulesState?: any;
+    /** Getter personalizado para valor calculado */
+    _generatedValueGetter?: string;
+    /** Tipo original da API */
+    _originalApiType?: string;
+    /** Flag indicando se veio da API */
+    _isApiField?: boolean;
+}
+/**
+ * Projeta as colunas publicadas pelo schema remoto e registra somente as
+ * diferenças editoriais da experiência. A chave de cada override é o nome
+ * canônico do campo; `field` permanece sob governança do schema.
+ */
+interface TableSchemaColumnProjectionConfig {
+    source: 'schema';
+    /** Allowlist ordenada. Quando omitida, usa todos os campos visíveis do schema. */
+    include?: string[];
+    /**
+     * Prioridade de apresentação por nome canônico, independente da allowlist.
+     * Campos elegíveis não listados seguem na ordem do schema, após os priorizados.
+     * Quando omitida, a ordem vem de include ou do schema. Remover order herda essa ordem.
+     */
+    order?: string[];
+    overrides?: Record<string, Partial<Omit<ColumnDefinition, 'field'>>>;
+    /**
+     * Colunas editoriais sem correspondente no schema, como colunas computadas.
+     * O runtime ignora uma adição cujo `field` colida com um campo canônico.
+     */
+    additions?: ColumnDefinition[];
+}
+interface ConfigMetadata {
+    /** Versão da configuração para migração automática */
+    version?: string;
+    /** Identificador único da configuração */
+    id?: string;
+    /** Nome amigável da configuração */
+    name?: string;
+    /** Descrição da configuração */
+    description?: string;
+    /** Tags para categorização e busca */
+    tags?: string[];
+    /** Data de criação */
+    createdAt?: string;
+    /** Data de última modificação */
+    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) */
+    derivedFrom?: string;
+    /** Identidade estrutural do schema de origem (path|operation|schemaType|internal:<bool>|idField|readOnly|origin) */
+    schemaId?: string;
+    /** ETag/hash do schema do servidor usado para a última reconciliação */
+    serverHash?: string;
+    /** Campo identificador preferido pelo usuário para o recurso (ex.: 'id', 'codigo') */
+    idField?: string;
+    /** Contexto de schema associado (útil para auditoria/telemetria) */
+    schemaContext?: {
+        path: string;
+        operation: string;
+        schemaType: 'response' | 'request';
+        internal?: boolean;
+        tenant?: string;
+        locale?: string;
+    };
+}
+interface TableBehaviorConfig {
+    /** Configurações de paginação */
+    pagination?: PaginationConfig;
+    /** Configurações de ordenação */
+    sorting?: SortingConfig;
+    /** Configurações de filtragem */
+    filtering?: FilteringConfig;
+    /** Configurações de agrupamento de linhas */
+    grouping?: GroupingConfig;
+    /** Configurações de seleção de linhas */
+    selection?: SelectionConfig;
+    /** Configurações de interação do usuário */
+    interaction?: InteractionConfig;
+    /** Configurações de carregamento e estados */
+    loading?: LoadingConfig;
+    /** Configurações para estado vazio */
+    emptyState?: EmptyStateConfig;
+    /** Configurações de virtualização para performance */
+    virtualization?: VirtualizationConfig;
+    /** Configurações de redimensionamento */
+    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;
+    detail?: TableDetailConfig;
+    /** Configurações de gaveta lateral / dossiê analítico (Issues #30 e #32) */
+    drawer?: TableDrawerConfig;
+    /** Configurações de faixa declarativa de KPIs / resumo executivo (Issue #33) */
+    kpiBand?: PraxisKpiBandConfig;
+    /** Configurações de campos computados / propriedades virtuais na ingestão (Issue #34) */
+    computedFields?: PraxisComputedFieldsConfig;
+}
+interface TableLocalDataModeConfig {
+    /** Habilita a trilha de modo local via input `[data]` */
+    enabled?: boolean;
+}
+/** Shared detail document, independently presented by row or current selection. */
+interface TableDetailConfig {
+    enabled?: boolean;
+    presentation?: {
+        placement?: 'row' | 'bottom';
+        initiallyCollapsed?: boolean;
+        /** Position of the contextual panel relative to collection-owned footer controls. */
+        bottomStackPosition?: 'beforeControls' | 'afterControls';
+        /** Whether the bottom panel keeps an instructional state when no record is selected. */
+        emptyBehavior?: 'message' | 'hide';
+    };
+    schemaContract?: {
+        kind?: 'praxis.detail.schema';
+        version?: string;
+        compat?: 'semver' | 'strict';
+        allowedNodes?: TableDetailAllowedNode[];
+        sanitization?: 'strict';
+    };
+    source?: {
+        mode?: 'inline' | 'resource' | 'resourcePath' | 'hypermedia' | 'schema';
+        inlineSchema?: TableDetailSchemaNode | TableDetailInlineSchemaDocument | RichContentDocument;
+        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?: {
+        /** @deprecated Reserved compatibility field; source.mode controls whether detail resolution is remote. */
+        enabled?: boolean;
+        /** @deprecated Reserved compatibility field; detail sources resolve through their declared provider/transport. */
+        actionId?: string;
+        cache?: {
+            enabled?: boolean;
+            /** @deprecated TTL is preserved during round-trip but is not enforced by the current runtime. */
+            ttlMs?: number;
+        };
+        /** @deprecated Retry settings are preserved during round-trip but are not executed by the current runtime. */
+        retry?: {
+            maxAttempts?: number;
+        };
+        cancelOnCollapse?: boolean;
+        /** @deprecated Requests are always deduplicated by the current row state; this override is not executed. */
+        dedupeByRowKey?: boolean;
+    };
+}
+interface TableExpansionConfig {
+    /** Habilita o recurso de expansão de linhas */
+    enabled?: boolean;
+    /** Origem de resolução do detalhe: 'schema' para auto-derivação por Bento Grid, ou modo customizado */
+    source?: 'schema' | 'custom' | string;
+    /** Modo de resolução do detalhe */
+    mode?: 'schema' | 'inline' | 'resource' | 'resourcePath' | 'hypermedia';
+    /** 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?: JsonLogicExpression | null;
+        onError?: 'deny' | 'allow';
+        context?: Array<'row' | 'computed' | 'user' | 'env'>;
+    };
+    /** 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 */
+    enabled: boolean;
+    /** Tamanho inicial da página */
+    pageSize: number;
+    /** Opções de tamanho de página disponíveis */
+    pageSizeOptions: number[];
+    /** Mostrar botões primeira/última página */
+    showFirstLastButtons: boolean;
+    /** Mostrar números das páginas */
+    showPageNumbers: boolean;
+    /** Mostrar info de página (ex: "1-10 de 100") */
+    showPageInfo: boolean;
+    /** Posição da paginação */
+    position: 'top' | 'bottom' | 'both';
+    /** Estilo da paginação */
+    style: 'default' | 'simple' | 'advanced' | 'compact';
+    /** Total de itens (para paginação server-side) */
+    totalItems?: number;
+    /** Estratégia de paginação */
+    strategy: 'client' | 'server';
+    /** Configurações avançadas */
+    advanced?: {
+        /** Jump to page input */
+        showJumpToPage?: boolean;
+        /** Page size customization */
+        allowCustomPageSize?: boolean;
+        /** Maximum page size allowed */
+        maxPageSize?: number;
+    };
+}
+interface SortingConfig {
+    /** Habilitar ordenação */
+    enabled: boolean;
+    /** Ordenação padrão inicial (suporta múltiplas entradas) */
+    defaultSort?: {
+        column: string;
+        direction: 'asc' | 'desc';
+    } | Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+    /** Permitir ordenação múltipla */
+    multiSort: boolean;
+    /** Estratégia de ordenação */
+    strategy: 'client' | 'server';
+    /** Mostrar indicadores visuais de ordenação */
+    showSortIndicators: boolean;
+    /** Posição dos indicadores */
+    indicatorPosition: 'start' | 'end';
+    /** Permitir remover ordenação (terceiro clique) */
+    allowClearSort: boolean;
+    /** Configurações avançadas */
+    advanced?: {
+        /** Função de comparação customizada para ordenação client-side */
+        customComparators?: {
+            [column: string]: (a: any, b: any) => number;
+        };
+        /** Preservar ordenação entre atualizações de dados */
+        preserveSort?: boolean;
+    };
+}
+interface GroupingConfig {
+    /** Habilitar agrupamento */
+    enabled: boolean;
+    /** Campos usados para agrupamento */
+    fields: string[];
+    /** Se os grupos iniciam expandidos */
+    expanded?: boolean;
+}
+/** Presentation of a filter region; never part of the backend filter DTO. */
+interface FilterPresentationConfig {
+    header?: {
+        visible?: boolean;
+        text?: string;
+        /** Empty string hides the icon. */
+        icon?: string;
+        position?: 'above' | 'inline';
+        size?: 'small' | 'medium' | 'large';
+    };
+    advancedAction?: {
+        display?: 'icon' | 'text' | 'icon-text';
+        /** Overrides i18n.advanced; omitted uses the localized label. */
+        text?: string;
+        /** Empty string hides the icon. */
+        icon?: string;
+        size?: 'compact' | 'standard';
+        /** Position within the auxiliary controls, not within the page. */
+        position?: 'start' | 'end';
+    };
+    tokens?: {
+        gap?: string;
+        headerGap?: string;
+        headerColor?: string;
+        headerFontSize?: string;
+        headerFontWeight?: string;
+        iconSize?: string;
+        actionGap?: string;
+        actionFontSize?: string;
+        actionFontWeight?: string;
+    };
+}
+interface FilteringConfig {
+    /** Habilitar filtragem */
+    enabled: boolean;
+    /** Filtros por coluna */
+    columnFilters?: {
+        enabled: boolean;
+        /** Tipo de filtro padrão */
+        defaultType: 'text' | 'select' | 'date' | 'number' | 'boolean';
+        /** Posição dos filtros */
+        position: 'header' | 'subheader' | 'sidebar';
+    };
+    /** Filtros avançados */
+    advancedFilters?: {
+        enabled: boolean;
+        /** Interface de query builder */
+        queryBuilder?: boolean;
+        /** Salvar filtros como presets */
+        savePresets?: boolean;
+        /** Configurações específicas do componente praxis-filter */
+        settings?: {
+            presentation?: FilterPresentationConfig;
+            /** Campos sempre visíveis */
+            alwaysVisibleFields?: 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;
+            /** Atalhos governados, somente leitura, aplicados como patch do DTO de filtro */
+            tags?: Array<{
+                id: string;
+                label: string;
+                patch: Record<string, any>;
+            }>;
+            /** Debounce de alterações para auto-aplicar filtros (ms) */
+            changeDebounceMs?: number;
+            /** 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 */
+    strategy: 'client' | 'server';
+    /** Debounce para filtros em tempo real (ms) */
+    debounceTime: number;
+}
+interface SelectionConfig {
+    /** Habilitar seleção de linhas */
+    enabled: boolean;
+    /** Tipo de seleção */
+    type: 'single' | 'multiple';
+    /** Modo de seleção */
+    mode: 'checkbox' | 'row' | 'both';
+    /** Permitir selecionar todas as linhas */
+    allowSelectAll: boolean;
+    /** Posição do checkbox de seleção */
+    checkboxPosition: 'start' | 'end';
+    /** Manter seleção entre páginas */
+    persistSelection: boolean;
+    /** Manter seleção entre atualizações de dados */
+    persistOnDataUpdate: boolean;
+    /** Máximo de itens selecionáveis */
+    maxSelections?: number;
+    /** Configurações visuais */
+    visual?: {
+        /** Highlight da linha selecionada */
+        highlightSelected: boolean;
+        /** Cor do highlight */
+        highlightColor?: string;
+        /** Mostrar contador de selecionados */
+        showSelectionCount: boolean;
+    };
+}
+interface InteractionConfig {
+    /** Ação ao clicar na linha */
+    rowClick?: {
+        enabled: boolean;
+        action: 'select' | 'edit' | 'view' | 'custom';
+        /** Função customizada para row click */
+        customAction?: string;
+    };
+    /** Ação ao dar duplo clique na linha */
+    rowDoubleClick?: {
+        enabled: boolean;
+        action: 'edit' | 'view' | 'custom';
+        customAction?: string;
+    };
+    /** Hover effects */
+    hover?: {
+        enabled: boolean;
+        /** Highlight na linha */
+        highlightRow: boolean;
+        /** Mostrar ações no hover */
+        showActionsOnHover: boolean;
+    };
+    /** Configurações de teclado */
+    keyboard?: {
+        enabled: boolean;
+        /** Navegação com setas */
+        arrowNavigation: boolean;
+        /** Seleção com espaço */
+        spaceSelection: boolean;
+        /** Atalhos personalizados */
+        customShortcuts?: {
+            [key: string]: string;
+        };
+    };
+}
+interface LoadingConfig {
+    /** Tipo de loading indicator */
+    type: 'spinner' | 'skeleton' | 'progress';
+    /** Posição do loading */
+    position: 'overlay' | 'inline' | 'replace';
+    /** Texto durante carregamento */
+    text?: string;
+    /** Mostrar loading para operações rápidas */
+    showForQuickOperations: boolean;
+    /** Delay antes de mostrar loading (ms) */
+    delay: number;
+    /**
+     * Limite para requests remotos de schema e dados. Use `0` somente quando o
+     * host possuir outra política de timeout governada.
+     */
+    requestTimeoutMs?: number;
+    /** Permite ao usuário cancelar requests remotos de schema e dados em andamento. */
+    allowCancel?: boolean;
+    /** Configurações de skeleton loading */
+    skeleton?: {
+        rows: number;
+        /** Animar skeleton */
+        animated: boolean;
+        /** Cor base do skeleton */
+        baseColor?: string;
+        /** Cor do highlight */
+        highlightColor?: string;
+    };
+}
+interface EmptyStateConfig {
+    /** Mensagem para estado vazio */
+    title?: string;
+    message: string;
+    description?: string;
+    /** Ícone para estado vazio */
+    icon?: string;
+    tone?: 'neutral' | 'primary' | 'secondary';
+    variant?: 'card' | 'inline' | 'panel' | 'transparent';
+    alignment?: 'start' | 'center';
+    density?: 'compact' | 'comfortable';
+    iconContainer?: 'none' | 'circle' | 'soft';
+    /** Imagem para estado vazio */
+    image?: string;
+    /** Ações disponíveis no estado vazio */
+    actions?: Array<{
+        label: string;
+        action: string;
+        icon?: string;
+        primary?: boolean;
+    }>;
+    /** Template customizado */
+    customTemplate?: string;
+    /** Configurações específicas por contexto */
+    contexts?: {
+        /** Estado inicial (sem dados carregados) */
+        initial?: Partial<EmptyStateConfig>;
+        /** Após filtros aplicados */
+        filtered?: Partial<EmptyStateConfig>;
+        /** Após busca sem resultados */
+        searched?: Partial<EmptyStateConfig>;
+    };
+}
+interface VirtualizationConfig {
+    /** Habilitar virtualização */
+    enabled?: boolean;
+    /** Altura de cada linha (px) */
+    itemHeight?: number;
+    /** Número de itens para buffer */
+    bufferSize?: number;
+    /** Altura mínima do container (px ou CSS) */
+    minContainerHeight?: number | string;
+    /** Estratégia de virtualização */
+    strategy?: 'fixed' | 'dynamic';
+}
+interface ResizingConfig {
+    /** Habilitar redimensionamento de colunas */
+    enabled: boolean;
+    /** Largura mínima das colunas */
+    minColumnWidth: number;
+    /** Largura máxima das colunas */
+    maxColumnWidth?: number;
+    /** Auto-fit ao conteúdo */
+    autoFit: boolean;
+    /** Preservar larguras entre sessões */
+    persistWidths: boolean;
+}
+interface DraggingConfig {
+    /** Habilitar reorganização de colunas */
+    columns: boolean;
+    /** Habilitar reorganização de linhas */
+    rows: boolean;
+    /** Indicador visual durante drag */
+    showDragIndicator: boolean;
+    /** Zona de drop para colunas */
+    columnDropZones?: string[];
+}
+interface TableAppearanceConfig {
+    /** Densidade da tabela */
+    density: 'compact' | 'comfortable' | 'spacious';
+    /** Configurações de bordas */
+    borders?: BorderConfig;
+    /** Configurações de cores */
+    colors?: ColorConfig;
+    /** Configurações de fonte */
+    typography?: TypographyConfig;
+    /** Configurações de espaçamento */
+    spacing?: SpacingConfig;
+    /** Configurações de animações */
+    animations?: AnimationConfig;
+    /** Configurações de responsividade */
+    responsive?: ResponsiveConfig;
+    /** Configurações de elevação/sombra */
+    elevation?: ElevationConfig;
+}
+interface BorderConfig {
+    /** Mostrar bordas entre linhas */
+    showRowBorders: boolean;
+    /** Mostrar bordas entre colunas */
+    showColumnBorders: boolean;
+    /** Mostrar borda externa */
+    showOuterBorder: boolean;
+    /** Estilo da borda */
+    style: 'solid' | 'dashed' | 'dotted';
+    /** Largura da borda */
+    width: number;
+    /** Cor da borda */
+    color?: string;
+    /** Bordas específicas */
+    specific?: {
+        header?: Partial<BorderConfig>;
+        footer?: Partial<BorderConfig>;
+        sticky?: Partial<BorderConfig>;
+    };
+}
+interface ColorConfig {
+    /** Cor de fundo da tabela */
+    background?: string;
+    /** Cor de fundo do cabeçalho */
+    headerBackground?: string;
+    /** Cor de fundo de linhas alternadas */
+    alternateRowBackground?: string;
+    /** Cor de fundo no hover */
+    hoverBackground?: string;
+    /** Cor de fundo para linhas selecionadas */
+    selectedBackground?: string;
+    /** Cor do texto */
+    textColor?: string;
+    /** Cor do texto do cabeçalho */
+    headerTextColor?: string;
+    /** Paleta de cores para estados */
+    states?: {
+        error?: string;
+        warning?: string;
+        success?: string;
+        info?: string;
+    };
+}
+interface TypographyConfig {
+    /** Família da fonte */
+    fontFamily?: string;
+    /** Tamanho da fonte do conteúdo */
+    fontSize?: string;
+    /** Tamanho da fonte do cabeçalho */
+    headerFontSize?: string;
+    /** Peso da fonte */
+    fontWeight?: number | string;
+    /** Peso da fonte do cabeçalho */
+    headerFontWeight?: number | string;
+    /** Altura da linha */
+    lineHeight?: string;
+    /** Espaçamento entre letras */
+    letterSpacing?: string;
+    /** Transformação do texto do cabeçalho */
+    headerCase?: 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+}
+interface SpacingConfig {
+    /** Padding das células */
+    cellPadding?: string;
+    /** Padding do cabeçalho */
+    headerPadding?: string;
+    /** Altura das linhas */
+    rowHeight?: number;
+    /** Altura do cabeçalho */
+    headerHeight?: number;
+    /** Espaçamento entre tabela e container */
+    containerSpacing?: string;
+}
+interface AnimationConfig {
+    /** Habilitar animações */
+    enabled: boolean;
+    /** Duração das animações (ms) */
+    duration: number;
+    /** Função de easing */
+    easing: string;
+    /** Animações específicas */
+    specific?: {
+        /** Animação ao carregar */
+        loading?: boolean;
+        /** Animação de hover */
+        hover?: boolean;
+        /** Animação de seleção */
+        selection?: boolean;
+        /** Animação de ordenação */
+        sorting?: boolean;
+    };
+}
+interface ResponsiveConfig {
+    /** Pontos de quebra */
+    breakpoints?: {
+        mobile?: number;
+        tablet?: number;
+        desktop?: number;
+    };
+    /** Comportamento em dispositivos móveis */
+    mobile?: {
+        /** Scroll horizontal */
+        horizontalScroll?: boolean;
+        /** Colapsar colunas */
+        collapseColumns?: boolean;
+        /** Colunas prioritárias */
+        priorityColumns?: string[];
+        /** Modo de cards em mobile */
+        cardMode?: boolean;
+    };
+    /** Ajustes automáticos */
+    autoAdjust?: {
+        /** Ocultar colunas automaticamente */
+        hideColumns?: boolean;
+        /** Reduzir font size */
+        scaleFontSize?: boolean;
+        /** Ajustar padding */
+        adjustPadding?: boolean;
+    };
+}
+interface ElevationConfig {
+    /** Nível de elevação */
+    level: number;
+    /** Cor da sombra */
+    shadowColor?: string;
+    /** Elevação no hover */
+    hoverElevation?: number;
+}
+interface ToolbarConfig {
+    /** Visibilidade da toolbar */
+    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;
+    /** Aparência governada da barra de ferramentas */
+    appearance?: TableToolbarAppearanceConfig;
+    /**
+     * Se true, preserva ações de coleção descobertas que não são suportadas pelo recurso
+     * (ex: criação em views read-only) sintetizando-as em estado desabilitado.
+     * Se false (padrão canônico da plataforma), ações não suportadas são omitidas da toolbar.
+     */
+    preserveUnsupportedActions?: boolean;
+    /** Configurações de layout */
+    layout?: ToolbarLayoutConfig;
+    /** Título da tabela */
+    title?: string;
+    /** Subtítulo da tabela */
+    subtitle?: string;
+    /** Ícone semântico exibido junto ao título da toolbar */
+    icon?: string;
+    /** Alinhamento textual da identidade da toolbar */
+    textAlign?: 'start' | 'center' | 'end';
+    /** Ações da toolbar */
+    actions?: ToolbarAction[];
+    /** Configurações de filtros na toolbar */
+    filters?: ToolbarFilterConfig;
+    /** Menu de configurações */
+    settingsMenu?: ToolbarSettingsConfig;
+    /** Controle rápido de visibilidade de colunas */
+    columnsVisibility?: {
+        enabled?: boolean;
+    };
+    /** Controle governado para alternar a densidade visual da tabela em runtime. */
+    densityToggle?: {
+        enabled?: boolean;
+        values?: TableToolbarAppearanceDensity[];
+    };
+}
+type TableToolbarAppearanceVariant = 'flat' | 'outlined' | 'elevated' | 'integrated';
+type TableToolbarAppearanceDensity = 'compact' | 'comfortable' | 'spacious';
+type TableToolbarAppearanceShape = 'square' | 'rounded' | 'pill';
+type TableToolbarAppearanceDivider = 'none' | 'start' | 'between-groups';
+type TableToolbarTokenName = 'bg' | 'fg' | 'borderColor' | 'borderWidth' | 'radius' | 'shadow' | 'paddingBlock' | 'paddingInline' | 'minHeight' | 'gap' | 'actionsGap' | 'dividerColor' | 'actionSize' | 'actionRadius' | 'actionBg' | 'actionFg' | 'actionHoverBg' | 'actionActiveBg' | 'actionFocusRing' | 'aiAccentColor' | 'statusFg' | 'titleFg' | 'subtitleFg' | 'iconFg' | 'titleFontSize' | 'subtitleFontSize' | 'titleFontWeight' | 'identityGap' | 'identityFilterGap' | 'identityMinHeight' | 'identityMarginBottom' | 'identityIconSize' | 'identityIconRadius';
+interface TableToolbarAppearanceConfig {
+    /** Preset registrado pelo host via @praxisui/table */
+    preset?: string;
+    /** Variante visual canônica da toolbar */
+    variant?: TableToolbarAppearanceVariant;
+    /** Densidade visual da toolbar */
+    density?: TableToolbarAppearanceDensity;
+    /** Forma dos containers e botões */
+    shape?: TableToolbarAppearanceShape;
+    /** Política de divisores entre regiões */
+    divider?: TableToolbarAppearanceDivider;
+    /** Tokens CSS públicos materializados pelo runtime */
+    tokens?: Partial<Record<TableToolbarTokenName, string>>;
+}
+interface ToolbarLayoutConfig {
+    /** Alinhamento do conteúdo */
+    alignment: 'start' | 'center' | 'end' | 'space-between';
+    /** Altura da toolbar */
+    height?: number;
+    /** Padding da toolbar */
+    padding?: string;
+    /** Cor de fundo */
+    backgroundColor?: string;
+    /** Mostrar separador */
+    showSeparator: boolean;
+}
+type ToolbarActionTargetScope = 'collection' | 'selection';
+interface ToolbarActionTargetCardinality {
+    /** Minimum number of records required to execute the action. */
+    min: number;
+    /** Maximum number accepted; omitted means no upper limit. */
+    max?: number;
+}
+interface ToolbarActionTarget {
+    /** Semantic action target, independent from its visual placement. */
+    scope: ToolbarActionTargetScope;
+    /** Selection constraint when the action targets selected records. */
+    cardinality?: ToolbarActionTargetCardinality;
+}
+interface ToolbarAction {
+    /** ID único da ação */
+    id: string;
+    /** Label da ação */
+    label: string;
+    /** Ícone da ação */
+    icon?: string;
+    /** Tipo do botão */
+    type: 'button' | 'icon' | 'fab' | 'menu';
+    /** Cor do Material */
+    color?: 'primary' | 'accent' | 'warn';
+    /** Aparência do botão Material: filled (flat), outlined (stroked), elevated (raised), text, tonal (custom) */
+    appearance?: 'filled' | 'outlined' | 'elevated' | 'text' | 'tonal';
+    /** Ação desabilitada */
+    disabled?: boolean;
+    /** Função a executar */
+    action: string;
+    /** Semantic target; toolbar placement does not imply a bulk operation. */
+    target?: ToolbarActionTarget;
+    /** Acao global estruturada executada pelo host via GlobalActionService */
+    globalAction?: GlobalActionRef;
+    /** Efeitos runtime canonicos executados quando a acao da toolbar e acionada */
+    effects?: PraxisRuntimeGlobalActionEffect[];
+    /** Tooltip */
+    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 */
+    order?: number;
+    /** Visibilidade condicional */
+    visibleWhen?: JsonLogicExpression | null;
+    /** Desabilitacao condicional */
+    disabledWhen?: JsonLogicExpression | null;
+    /** Sub-ações (para menus) */
+    children?: ToolbarAction[];
+}
+interface ToolbarFilterConfig {
+    /** Habilitar filtros rápidos na toolbar */
+    enabled: boolean;
+    /** Filtros rápidos disponíveis */
+    quickFilters?: Array<{
+        id: string;
+        label: string;
+        filter: any;
+        icon?: string;
+    }>;
+    /** Mostrar botões de filtros rápidos na toolbar (default: true) */
+    showQuickFilters?: boolean;
+    /** Mostrar botão de filtros avançados */
+    showAdvancedButton: boolean;
+}
+interface ToolbarSettingsConfig {
+    /** Habilitar menu de configurações */
+    enabled: boolean;
+    /** Configurações disponíveis */
+    options?: Array<{
+        id: string;
+        label: string;
+        type: 'toggle' | 'select' | 'action';
+        value?: any;
+        options?: any[];
+    }>;
+}
+interface TableAiAssistantConfig {
+    /** Exibe e permite acionar o assistente de IA da tabela. Ausente equivale a true. */
+    enabled?: boolean;
+}
+interface TableAiConfig {
+    /** Configuracoes do assistente de IA embarcado na tabela. */
+    assistant?: TableAiAssistantConfig;
+}
+interface TableActionsConfig {
+    /** Políticas para ações no escopo da coleção */
+    collection?: CollectionActionsConfig;
+    /** Ações por linha */
+    row?: RowActionsConfig;
+    /** Ações em lote */
+    bulk?: BulkActionsConfig;
+    /** Ações de contexto (menu com botão direito) */
+    context?: ContextActionsConfig;
+    /** Configurações de confirmação */
+    confirmations?: ConfirmationConfig;
+}
+interface CollectionActionsConfig {
+    /** Descoberta HATEOAS/capabilities para materializar ações da coleção */
+    discovery?: {
+        /**
+         * Habilita a materialização de ações de coleção descobertas, como create e workflows.
+         * Ausente equivale a true.
+         */
+        enabled?: boolean;
+    };
+}
+interface RowActionsConfig {
+    /** Habilitar ações por linha */
+    enabled: boolean;
+    /** Posição das ações */
+    position: 'start' | 'end';
+    /** Largura da coluna de ações */
+    width?: string;
+    /** Fixar a coluna de ações */
+    sticky?: boolean | 'start' | 'end';
+    /** Ações disponíveis */
+    actions: RowAction[];
+    /** Formato de exibição */
+    display: 'menu' | 'buttons' | 'icons';
+    /** Trigger para mostrar ações */
+    trigger: 'hover' | 'always' | 'click';
+    /** Ícone do menu de ações */
+    menuIcon?: string;
+    /** Cor do botão do menu de ações (overflow) */
+    menuButtonColor?: 'basic' | 'primary' | 'accent' | 'warn';
+    /** Descoberta HATEOAS/capabilities para enriquecer ações de linha */
+    discovery?: {
+        /** Habilitar descoberta contextual de actions/capabilities para a linha */
+        enabled?: boolean;
+    };
+    /** Configurações do cabeçalho da coluna de ações */
+    header?: {
+        /** Texto exibido no cabeçalho (ex.: "Ações") */
+        label?: string;
+        /** Ícone exibido ao lado do texto */
+        icon?: string;
+        /** Tooltip do cabeçalho */
+        tooltip?: string;
+        /** Alinhamento do conteúdo no cabeçalho */
+        align?: 'start' | 'center' | 'end';
+    };
+    /** Número máximo de ações visíveis */
+    maxVisibleActions?: number;
+    /** Comportamento de overflow de ações */
+    behavior?: {
+        /** Habilitar comportamento de overflow */
+        enabled?: boolean;
+        /** Número máximo de ações inline */
+        maxInline?: number | 'auto' | {
+            xs?: number;
+            sm?: number;
+            md?: number;
+            lg?: number;
+        };
+        /** Estratégia para auto determinar número de ações inline */
+        autoStrategy?: 'measure' | 'breakpoints';
+    };
+}
+interface RowAction {
+    /** ID único da ação */
+    id: string;
+    /** Label da ação */
+    label: string;
+    /** Ícone da ação */
+    icon?: string;
+    /** Cor da ação */
+    color?: string;
+    /** Ação desabilitada */
+    disabled?: boolean;
+    /** Função a executar */
+    action: string;
+    /** Acao global estruturada executada pelo host via GlobalActionService */
+    globalAction?: GlobalActionRef;
+    /** Efeitos runtime canonicos executados quando a acao por linha e acionada */
+    effects?: PraxisRuntimeGlobalActionEffect[];
+    /** Surface de registro canonica aberta por esta acao de linha */
+    recordSurface?: ResourceSurfaceCatalogItem;
+    /** Tooltip */
+    tooltip?: string;
+    /** Requer confirmação */
+    requiresConfirmation?: boolean;
+    /** Visibilidade condicional */
+    visibleWhen?: JsonLogicExpression | null;
+    /** Separador após esta ação */
+    separator?: boolean;
+    /** Habilita exclusão automática ao acionar */
+    autoDelete?: boolean;
+    /** Endpoint personalizado para exclusão */
+    deleteEndpoint?: string;
+}
+interface BulkActionsConfig {
+    /** Habilitar ações em lote */
+    enabled: boolean;
+    /** Posição das ações em lote */
+    position: 'toolbar' | 'floating' | 'both';
+    /** Ações disponíveis */
+    actions: BulkAction[];
+    /** Configurações do floating action button */
+    floating?: {
+        position: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+        /** Ocultar quando nada selecionado */
+        hideWhenEmpty: boolean;
+    };
+}
+interface BulkAction {
+    /** ID único da ação */
+    id: string;
+    /** Label da ação */
+    label: string;
+    /** Ícone da ação */
+    icon?: string;
+    /** Cor da ação */
+    color?: string;
+    /** Função a executar */
+    action: string;
+    /** Acao global estruturada executada pelo host via GlobalActionService */
+    globalAction?: GlobalActionRef;
+    /** Efeitos runtime canonicos executados quando a acao em lote e acionada */
+    effects?: PraxisRuntimeGlobalActionEffect[];
+    /** Requer confirmação */
+    requiresConfirmation?: boolean;
+    /** Mínimo de itens selecionados */
+    minSelections?: number;
+    /** Máximo de itens selecionados */
+    maxSelections?: number;
+    /** Habilita exclusão automática ao acionar */
+    autoDelete?: boolean;
+    /** Endpoint personalizado para exclusão */
+    deleteEndpoint?: string;
+}
+interface ContextActionsConfig {
+    /** Habilitar menu de contexto */
+    enabled: boolean;
+    /** Ações do menu de contexto */
+    actions: ContextAction[];
+    /** Trigger para menu de contexto */
+    trigger: 'right-click' | 'long-press' | 'both';
+}
+interface ContextAction {
+    /** ID único da ação */
+    id: string;
+    /** Label da ação */
+    label: string;
+    /** Ícone da ação */
+    icon?: string;
+    /** Função a executar */
+    action: string;
+    /** Separador após esta ação */
+    separator?: boolean;
+    /** Visibilidade condicional */
+    visibleWhen?: JsonLogicExpression | null;
+}
+interface ConfirmationConfig {
+    /** Configurações padrão de confirmação */
+    default?: {
+        title: string;
+        message: string;
+        confirmText: string;
+        cancelText: string;
+    };
+    /** Configurações específicas por ação */
+    specific?: {
+        [actionId: string]: Partial<ConfirmationConfig['default']>;
+    };
+}
+type TableDetailAllowedNode = 'layout' | 'stack' | 'tabs' | 'tab' | 'text' | 'icon' | 'image' | 'badge' | 'avatar' | 'metric' | 'progress' | 'compose' | 'card' | 'mediaBlock' | 'cardGrid' | 'timeline' | 'value' | 'action' | 'actionBar' | 'list' | 'detailList' | 'formRef' | 'tableRef' | 'chartRef' | 'diagramEmbed' | 'richText' | 'richContent' | 'templateRef';
+interface TableDetailBaseNode {
+    type: TableDetailAllowedNode;
+    id?: string;
+    title?: string;
+    subtitle?: string;
+    visibleWhen?: JsonLogicExpression | null;
+    [key: string]: unknown;
+}
+interface TableDetailLayoutNode extends TableDetailBaseNode {
+    type: 'layout' | 'stack';
+    items?: TableDetailSchemaNode[];
+    content?: TableDetailSchemaNode[];
+}
+interface TableDetailTabsNode extends TableDetailBaseNode {
+    type: 'tabs';
+    items?: TableDetailTabNode[];
+    content?: TableDetailTabNode[];
+}
+interface TableDetailTabNode extends TableDetailBaseNode {
+    type: 'tab';
+    badge?: string | number;
+    icon?: string;
+    items?: TableDetailSchemaNode[];
+    content?: TableDetailSchemaNode[];
+}
+interface TableDetailCardNode extends TableDetailBaseNode {
+    type: 'card';
+    items?: TableDetailSchemaNode[];
+    content?: TableDetailSchemaNode[];
+}
+interface TableDetailCardGridCardNode {
+    id?: string;
+    title?: string;
+    subtitle?: string;
+    content: Array<RichPresenterNode | RichComposeNode>;
+}
+interface TableDetailCardGridNode extends TableDetailBaseNode {
+    type: 'cardGrid';
+    title?: string;
+    subtitle?: string;
+    columns?: 1 | 2 | 3 | 4 | 'auto';
+    minCardWidth?: number;
+    cards: TableDetailCardGridCardNode[];
+}
+interface TableDetailMediaBlockNode extends RichMediaBlockNode {
+    type: 'mediaBlock';
+}
+interface TableDetailTimelineItemSchema {
+    titleField?: string;
+    subtitleField?: string;
+    metaField?: string;
+    iconField?: string;
+    badgeField?: string;
+}
+interface TableDetailTimelineStaticItem {
+    id?: string;
+    title?: string;
+    titleExpr?: string;
+    subtitle?: string;
+    subtitleExpr?: string;
+    meta?: string;
+    metaExpr?: string;
+    icon?: string;
+    iconExpr?: string;
+    badge?: string;
+    badgeExpr?: string;
+    [key: string]: unknown;
+}
+interface TableDetailTimelineNode extends TableDetailBaseNode {
+    type: 'timeline';
+    field?: string;
+    items?: Array<TableDetailTimelineStaticItem | string | number | boolean | bigint | unknown[]>;
+    emptyText?: string;
+    itemSchema?: TableDetailTimelineItemSchema;
+}
+interface TableDetailValueNode extends TableDetailBaseNode {
+    type: 'value';
+    field?: string;
+    valueField?: string;
+    value?: unknown;
+}
+interface TableDetailActionNode extends TableDetailBaseNode {
+    type: 'action';
+    actionId?: string;
+    icon?: string;
+    payloadExpr?: string;
+    disabled?: boolean;
+    statusText?: string;
+}
+interface TableDetailActionBarAction {
+    actionId: string;
+    label: string;
+    icon?: string;
+    payloadExpr?: string;
+    visibleWhen?: JsonLogicExpression | null;
+    disabledWhen?: JsonLogicExpression | null;
+}
+interface TableDetailActionBarNode extends TableDetailBaseNode {
+    type: 'actionBar';
+    emptyText?: string;
+    actions: TableDetailActionBarAction[];
+}
+interface TableDetailListNode extends TableDetailBaseNode {
+    type: 'list';
+    field?: string;
+    items?: unknown[];
+    emptyText?: string;
+}
+interface TableDetailListItemContextConfig {
+    itemAlias?: string;
+    indexAlias?: string;
+}
+interface TableDetailListItemSchema {
+    layout?: 'stack' | 'row' | 'card-list';
+    nodes: RichBlockNode[];
+}
+interface TableDetailListItemAction {
+    actionId: string;
+    label: string;
+    icon?: string;
+    payloadExpr?: string;
+    visibleWhen?: JsonLogicExpression | null;
+    disabledWhen?: JsonLogicExpression | null;
+}
+interface TableDetailRichListNode extends TableDetailBaseNode {
+    type: 'detailList';
+    field?: string;
+    items?: unknown[];
+    emptyText?: string;
+    itemKeyField?: string;
+    itemSchema: TableDetailListItemSchema;
+    itemContext?: TableDetailListItemContextConfig;
+    itemActions?: TableDetailListItemAction[];
+}
+type TableDetailEmbedAction = TableDetailActionBarAction;
+interface TableDetailEmbedBaseNode extends TableDetailBaseNode {
+    /**
+     * Governs whether the detail row should keep this embed as a host-mediated reference
+     * or ask an owning runtime/provider to materialize it inline. Omitted means `reference`.
+     */
+    renderMode?: 'reference' | 'inline';
+    description?: string;
+    caption?: string;
+    emptyText?: string;
+    inputs?: Record<string, unknown>;
+    presetRef?: CorePresetRef;
+    action?: TableDetailEmbedAction;
+}
+interface TableDetailRefNode extends TableDetailEmbedBaseNode {
+    type: 'formRef' | 'tableRef' | 'chartRef';
+    schemaId?: string;
+    chartDocumentRef?: string;
+    chartDocument?: unknown;
+}
+interface TableDetailDiagramEmbedNode extends TableDetailEmbedBaseNode {
+    type: 'diagramEmbed';
+    provider: 'mermaid' | 'bpmn' | 'custom';
+    source?: string;
+    sourceField?: string;
+}
+interface TableDetailRichTextNode extends TableDetailBaseNode {
+    type: 'richText';
+    html?: string;
+    text?: string;
+}
+/**
+ * Host-mediated node embedding a canonical Praxis Rich Content document inside a table row expansion
+ * or bottom detail panel. Live Expressions within the document automatically resolve against the current
+ * row, metadata, and variables declared in `contextMap`.
+ */
+interface TableDetailRichContentNode extends TableDetailBaseNode {
+    type: 'richContent';
+    /** Canonical Rich Content Document structure to render. */
+    document: RichContentDocument;
+    /** Layout presentation mode: 'block' fills available width, 'inline' respects content flow. */
+    layout?: 'block' | 'inline';
+    /** Optional CSS class applied to the root container of the rich content document. */
+    rootClassName?: string;
+    /**
+     * Expression mapping injecting row properties into the Rich Content context for Live Expressions.
+     * Supports `$row.<property>`, `row.<property>`, or direct `<property>` names from the active row record.
+     *
+     * Example:
+     * ```json
+     * { "missionCode": "$row.codigo", "riskLevel": "nivelRisco" }
+     * ```
+     */
+    contextMap?: Record<string, string>;
+    /** Static or predefined values injected directly into the document context. */
+    context?: Record<string, unknown>;
+}
+interface TableDetailTemplateRefNode extends TableDetailEmbedBaseNode {
+    type: 'templateRef';
+    templateId?: string;
+}
+type TableDetailSchemaNode = TableDetailLayoutNode | TableDetailTabsNode | TableDetailTabNode | TableDetailCardNode | TableDetailMediaBlockNode | TableDetailCardGridNode | TableDetailTimelineNode | TableDetailValueNode | TableDetailActionNode | TableDetailActionBarNode | TableDetailListNode | TableDetailRichListNode | TableDetailRefNode | TableDetailDiagramEmbedNode | TableDetailRichTextNode | TableDetailRichContentNode | TableDetailTemplateRefNode;
+/**
+ * Composite inline schema document container for table row expansion and bottom detail panels.
+ */
+interface TableDetailInlineSchemaDocument {
+    /** Structural arrangement of root items: stacked list or tabbed multi-dossier view. */
+    layout?: 'stack' | 'tabs';
+    /** Child detail nodes to render. Also supports direct `RichContentDocument` entries. */
+    items?: TableDetailSchemaNode[];
+    /**
+     * Document-level expression mapping injecting row attributes into the detail evaluation context.
+     * Keys mapped here are available across all child nodes and Live Expressions.
+     */
+    contextMap?: Record<string, string>;
+}
+/**
+ * Configuração canônica de gaveta lateral (Drawer) / dossiê analítico na tabela.
+ * Suporta modo analítico com abas, bento cards e sub-recursos/relações declarativas.
+ * (Issues #30 e #32)
+ */
+interface TableDrawerConfig {
+    /** Habilita a gaveta lateral de detalhe analítico */
+    enabled?: boolean;
+    /** Modo de abertura: 'analytical' (dossiê com abas/cards) ou 'form' */
+    mode?: 'analytical' | 'form' | string;
+    type?: 'analytical' | 'form' | string;
+    /** Título estático ou expressão dinâmica (SafeExpressionEvaluator) */
+    title?: string;
+    titleExpr?: string;
+    /** Subtítulo estático ou expressão dinâmica */
+    subtitle?: string;
+    subtitleExpr?: string;
+    /** Ícone no cabeçalho da gaveta */
+    icon?: string;
+    /** Pílula de classificação corporativa no topo (ex.: "DOSSIÊ DE INVESTIGAÇÃO · PRAXIS GOVERNED") */
+    classificationPill?: string;
+    /** Largura customizada da gaveta (ex.: 'min(780px, 60vw)', '680px') */
+    width?: string;
+    /** Se verdadeiro, o clique na linha da tabela abre a gaveta automaticamente. Padrão: true quando drawer habilitado. */
+    openOnRowClick?: boolean;
+    /** Esquema analítico do dossiê (com abas e nós de apresentação) */
+    schema?: PraxisAnalyticalDrawerSchema | TableDetailInlineSchemaDocument | RichContentDocument;
+    /** Lista direta de abas analíticas (atalho equivalente a schema.tabs) */
+    tabs?: PraxisAnalyticalDrawerTab[];
+    /** Orquestração declarativa de sub-recursos e relações vinculadas (Issue #32) */
+    relations?: PraxisAnalyticalDrawerRelation[];
+}
+/**
+ * Esquema estrutural canônico para gavetas analíticas e dossiês multi-aba (`kind: 'praxis.analytical-drawer.schema'`).
+ */
+interface PraxisAnalyticalDrawerSchema {
+    kind?: 'praxis.analytical-drawer.schema';
+    version?: '1.0.0' | string;
+    titleExpr?: string;
+    subtitleExpr?: string;
+    icon?: string;
+    classificationPill?: string;
+    tabs: PraxisAnalyticalDrawerTab[];
+    relations?: PraxisAnalyticalDrawerRelation[];
+}
+/**
+ * Definição de aba temática dentro de uma gaveta analítica.
+ */
+interface PraxisAnalyticalDrawerTab {
+    id: string;
+    label: string;
+    icon?: string;
+    badge?: string;
+    count?: number;
+    content?: TableDetailSchemaNode | TableDetailInlineSchemaDocument | RichContentDocument | Record<string, unknown>;
+}
+/**
+ * Contrato declarativo de sub-recurso / relação vinculada para injeção automática no contexto reativo (`context.relations`).
+ * (Issue #32)
+ */
+interface PraxisAnalyticalDrawerRelation {
+    /** Chave injetada no contexto do template (ex.: 'indicadoresRisco' -> relations.indicadoresRisco) */
+    key: string;
+    /** URL ou endpoint com suporte a tokens de interpolação da linha (ex.: '/api/operations/incidentes/{id}/risk-indicators') */
+    endpoint: string;
+    /** Método HTTP. Padrão: 'GET' */
+    method?: 'GET' | 'POST';
+    /** Cardinalidade esperada: 'single' (primeiro objeto) ou 'collection' (array). Padrão: 'single' */
+    cardinality?: 'single' | 'collection';
+    /** Se deve armazenar resposta em cache por URL para a sessão. Padrão: true */
+    cache?: boolean;
+    /** Se o fetch deve ser postergado até a aba que consome a relação ficar visível */
+    lazy?: boolean;
+    /** Mapeamento adicional de parâmetros */
+    paramsMap?: Record<string, string>;
+}
+interface PraxisKpiBandCard {
+    /** Identificador único do card de métrica */
+    id?: string;
+    /** Rótulo principal da métrica (ex.: 'Total de Missões', 'Heróis Ativos') */
+    label: string;
+    /** Expressão segura para derivar o valor a partir do contexto `{ data, stats, ...data }` */
+    valueExpr?: string;
+    /** Valor estático ou pré-calculado (se valueExpr não for utilizado) */
+    value?: string | number | null;
+    /**
+     * Formato semântico do valor:
+     * - 'currency:BRL' | 'currency:compactBRL' (ex: R$ 3,1M)
+     * - 'number' | 'number:compact' (ex: 125K)
+     * - 'percent' | 'percentage'
+     * - string customizada
+     */
+    format?: string;
+    /** Subtítulo / legenda estática */
+    caption?: string;
+    /** Expressão segura para derivar a legenda dinamicamente */
+    captionExpr?: string;
+    /** Nota de rodapé ou metadado contextual (ex.: 'Atualizado há 5 min', 'Mês corrente') */
+    footnote?: string;
+    /** Ícone Angular Material / Praxis a ser renderizado */
+    icon?: string;
+    /** Tom visual semântico do card */
+    tone?: 'info' | 'success' | 'warning' | 'error' | 'neutral' | string;
+    /** Ação ou evento emitido ao clicar no card */
+    action?: string;
+    /** Se o card é explicitamente clicável / interativo (quando omitido, derivado da presença de action, filter ou ouvintes) */
+    interactive?: boolean;
+    /** Filtro ou critérios de filtragem a serem aplicados diretamente à tabela ao clicar no card */
+    filter?: Record<string, unknown>;
+    /** Rota ou link para navegação opcional ao clicar no card */
+    route?: string;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Tooltip explicativo ao pairar o mouse */
+    tooltip?: string;
+}
+interface PraxisKpiBandConfig {
+    /** Se a faixa de KPIs está habilitada (padrão: true quando configurada) */
+    enabled?: boolean;
+    /** Endpoint URL para auto-fetch das estatísticas agregadas (ex.: '/operations/vw-resumo-missoes/stats/summary') */
+    source?: string;
+    /** Método HTTP para a requisição de auto-fetch (padrão: 'GET') */
+    method?: 'GET' | 'POST';
+    /** Payload enviado em requisições POST para a source */
+    payload?: Record<string, unknown>;
+    /** Layout dos cards: 'grid' (Bento / CSS Grid) ou 'flex' (padrão: 'grid') */
+    layout?: 'grid' | 'flex';
+    /** Número de colunas no layout grid (padrão: auto-fit com minmax) */
+    columns?: number;
+    /** Espaçamento entre os cards ('sm' | 'md' | 'lg' | customizado) */
+    gap?: 'sm' | 'md' | 'lg' | string;
+    /** Lista de cards de métricas declarados */
+    cards?: PraxisKpiBandCard[];
+    /** Documento Rich Content alternativo quando a faixa é definida via layout Rich Content */
+    document?: RichContentDocument;
+    /** Se deve exibir botão de recarregar / refresh na faixa */
+    showRefresh?: boolean;
+    /** Título opcional da seção executiva */
+    title?: string;
+    /** Subtítulo opcional da seção executiva */
+    subtitle?: string;
+    /** Classes CSS adicionais para o container da faixa */
+    className?: string;
+}
+interface PraxisComputedFieldDefinition {
+    /** Tipo semântico da propriedade calculada */
+    type?: 'string' | 'number' | 'boolean' | 'date' | 'currency' | 'percentage';
+    /** Expressão segura para cálculo (ex.: 'salarioBase * 0.89', 'danosCivis > 50000 ? "ALTO" : "NORMAL"') */
+    expr: string;
+    /** Formato semântico opcional (ex.: 'currency:BRL', 'date:pt-BR', 'number:0.2-2') */
+    format?: string;
+    /** Valor padrão / fallback em caso de erro de avaliação */
+    fallback?: unknown;
+}
+/**
+ * Mapeamento de propriedades computadas injetadas na ingestão de dados da tabela.
+ * Pode ser um mapa de chave para `PraxisComputedFieldDefinition` ou string simples (expressão).
+ */
+type PraxisComputedFieldsConfig = Record<string, PraxisComputedFieldDefinition | string>;
+interface ExportConfig {
+    /** Habilitar exportação */
+    enabled: boolean;
+    /** Formatos disponíveis */
+    formats: ExportFormat[];
+    /** Configurações por formato */
+    excel?: ExcelExportConfig;
+    pdf?: PdfExportConfig;
+    csv?: CsvExportConfig;
+    json?: JsonExportConfig;
+    /** Configurações gerais */
+    general?: GeneralExportConfig;
+    /** Templates personalizados */
+    templates?: ExportTemplate[];
+}
+type ExportFormat = PraxisExportFormat;
+interface GeneralExportConfig {
+    /** Incluir cabeçalhos */
+    includeHeaders: boolean;
+    /** Escopo canônico dos dados exportados */
+    scope: PraxisExportScope;
+    /** Máximo de linhas para exportar */
+    maxRows?: number;
+    /** Nome do arquivo padrão */
+    defaultFileName?: string;
+    /** Colunas a incluir na exportação */
+    includeColumns?: string[] | 'all' | 'visible';
+    /** Aplicar formatações das colunas */
+    applyFormatting: boolean;
+}
+interface ExcelExportConfig {
+    /** Nome da planilha */
+    sheetName: string;
+    /** Exibir ação local para exportar a página atual com colunas visíveis */
+    visibleCurrentPage?: boolean;
+    /** Incluir fórmulas nas células */
+    includeFormulas: boolean;
+    /** Congelar linha de cabeçalho */
+    freezeHeaders: boolean;
+    /** Auto-ajustar largura das colunas */
+    autoFitColumns: boolean;
+    /** Configurações de estilo */
+    styling?: ExcelStylingConfig;
+    /** Múltiplas planilhas */
+    multipleSheets?: boolean;
+}
+interface ExcelStylingConfig {
+    /** Estilo do cabeçalho */
+    headerStyle?: {
+        backgroundColor?: string;
+        fontColor?: string;
+        fontWeight?: 'bold' | 'normal';
+        fontSize?: number;
+    };
+    /** Estilo das células */
+    cellStyle?: {
+        fontSize?: number;
+        borderStyle?: 'thin' | 'medium' | 'thick';
+    };
+    /** Linhas alternadas */
+    alternateRows?: {
+        enabled: boolean;
+        color?: string;
+    };
+}
+interface PdfExportConfig {
+    /** Orientação da página */
+    orientation: 'portrait' | 'landscape';
+    /** Tamanho da página */
+    pageSize: 'A4' | 'A3' | 'Letter' | 'Legal';
+    /** Margens da página */
+    margins: MarginConfig;
+    /** Cabeçalho do documento */
+    header?: string;
+    /** Rodapé do documento */
+    footer?: string;
+    /** Marca d'água */
+    watermark?: string;
+    /** Configurações de fonte */
+    font?: {
+        family?: string;
+        size?: number;
+    };
+    /** Quebra de página automática */
+    autoPageBreak: boolean;
+}
+interface MarginConfig {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface CsvExportConfig {
+    /** Separador de campos */
+    delimiter: ',' | ';' | '|' | '\t';
+    /** Caractere de escape */
+    escapeChar: string;
+    /** Encoding do arquivo */
+    encoding: 'utf-8' | 'utf-16' | 'iso-8859-1';
+    /** Incluir BOM */
+    includeBOM: boolean;
+}
+interface JsonExportConfig {
+    /** Formato do JSON */
+    format: 'pretty' | 'compact';
+    /** Incluir metadados */
+    includeMetadata: boolean;
+    /** Estrutura dos dados */
+    structure: 'array' | 'object';
+}
+interface ExportTemplate {
+    /** ID único do template */
+    id: string;
+    /** Nome do template */
+    name: string;
+    /** Descrição */
+    description?: string;
+    /** Formato do template */
+    format: ExportFormat;
+    /** Configurações específicas */
+    config: any;
+    /** Template padrão do sistema */
+    isDefault?: boolean;
+}
+interface MessagesConfig {
+    /** Mensagens de estado */
+    states?: StateMessagesConfig;
+    /** Mensagens de ações */
+    actions?: ActionMessagesConfig;
+    /** Mensagens de validação */
+    validation?: ValidationMessagesConfig;
+    /** Mensagens de exportação */
+    export?: ExportMessagesConfig;
+    /** Mensagens customizadas */
+    custom?: {
+        [key: string]: string;
+    };
+    /** Templates de mensagem com interpolação */
+    templates?: MessageTemplate[];
+}
+interface StateMessagesConfig {
+    /** Carregando dados */
+    loading: string;
+    /** Nenhum dado disponível */
+    empty: string;
+    /** Erro ao carregar */
+    error: string;
+    /** Nenhum resultado encontrado */
+    noResults: string;
+    /** Carregando mais dados */
+    loadingMore: string;
+    /** Mensagens dinâmicas com contador */
+    dynamic?: {
+        /** Função para mensagem de loading com contagem */
+        loadingWithCount?: (count: number) => string;
+        /** Função para estado vazio com filtros */
+        emptyWithFilter?: (filterCount: number) => string;
+        /** Função para resultado de busca */
+        searchResults?: (resultCount: number, searchTerm: string) => string;
+    };
+}
+interface ActionMessagesConfig {
+    /** Mensagens de confirmação */
+    confirmations?: {
+        delete: string;
+        deleteMultiple: string;
+        save: string;
+        cancel: string;
+        export: string;
+    };
+    /** Mensagens de sucesso */
+    success?: {
+        save: string;
+        delete: string;
+        export: string;
+        import: string;
+    };
+    /** Mensagens de progresso */
+    progress?: {
+        delete: string;
+        deleteMultiple: string;
+    };
+    /** Mensagens de cancelamento */
+    canceled?: {
+        delete: string;
+        deleteMultiple: string;
+    };
+    /** Mensagens de erro */
+    errors?: {
+        save: string;
+        delete: string;
+        export: string;
+        network: string;
+        permission: string;
+    };
+}
+interface ValidationMessagesConfig {
+    /** Mensagens de validação de dados */
+    required: string;
+    invalid: string;
+    tooLong: string;
+    tooShort: string;
+    /** Mensagens específicas por tipo */
+    types?: {
+        email: string;
+        url: string;
+        number: string;
+        date: string;
+    };
+}
+interface ExportMessagesConfig {
+    /** Iniciando exportação */
+    starting: string;
+    /** Processando dados */
+    processing: string;
+    /** Download pronto */
+    ready: string;
+    /** Erro na exportação */
+    error: string;
+    /** Mensagens por formato */
+    formats?: {
+        excel: string;
+        pdf: string;
+        csv: string;
+        json: string;
+    };
+}
+interface MessageTemplate {
+    /** ID único do template */
+    id: string;
+    /** Template da mensagem com placeholders */
+    template: string;
+    /** Variáveis disponíveis */
+    variables?: string[];
+    /** Função de interpolação customizada */
+    interpolate?: (template: string, data: any) => string;
+}
+interface LocalizationConfig {
+    /** Idioma principal */
+    locale: string;
+    /** Idiomas disponíveis */
+    availableLocales?: string[];
+    /** Direção do texto */
+    direction: 'ltr' | 'rtl';
+    /** Configurações de data/hora */
+    dateTime?: DateTimeLocaleConfig;
+    /** Configurações de números */
+    number?: NumberLocaleConfig;
+    /** Configurações de moeda */
+    currency?: CurrencyLocaleConfig;
+    /** Dicionário de traduções */
+    translations?: {
+        [locale: string]: {
+            [key: string]: string;
+        };
+    };
+    /** Configurações de formatação */
+    formatting?: FormattingLocaleConfig;
+}
+interface DateTimeLocaleConfig {
+    /** Formato de data padrão */
+    dateFormat: string;
+    /** Formato de hora padrão */
+    timeFormat: string;
+    /** Formato de data e hora */
+    dateTimeFormat: string;
+    /** Primeiro dia da semana (0 = domingo) */
+    firstDayOfWeek: number;
+    /** Nomes dos meses */
+    monthNames?: string[];
+    /** Nomes dos dias da semana */
+    dayNames?: string[];
+    /** Formato relativo (há 2 dias) */
+    relativeTime?: boolean;
+}
+interface NumberLocaleConfig {
+    /** Separador decimal */
+    decimalSeparator: string;
+    /** Separador de milhares */
+    thousandsSeparator: string;
+    /** Número de casas decimais padrão */
+    defaultPrecision: number;
+    /** Símbolo de negativo */
+    negativeSign: string;
+    /** Posição do símbolo de negativo */
+    negativeSignPosition: 'before' | 'after';
+}
+interface CurrencyLocaleConfig {
+    /** Código da moeda (ISO 4217) */
+    code: string;
+    /** Símbolo da moeda */
+    symbol: string;
+    /** Posição do símbolo */
+    position: 'before' | 'after';
+    /** Espaço entre símbolo e valor */
+    spacing: boolean;
+    /** Precisão padrão */
+    precision: number;
+}
+interface FormattingLocaleConfig {
+    /** Formato de porcentagem */
+    percentageFormat: string;
+    /** Formato de arquivos/tamanhos */
+    fileSizeFormat: 'binary' | 'decimal';
+    /** Unidades de medida */
+    units?: {
+        [type: string]: {
+            [unit: string]: string;
+        };
+    };
+}
+interface DataConfig {
+    /** Estratégia de carregamento */
+    loadingStrategy: 'eager' | 'lazy' | 'on-demand';
+    /** Configurações de cache */
+    cache?: CacheConfig;
+    /** Configurações de sincronização */
+    sync?: SyncConfig;
+    /** Configurações de validação */
+    validation?: DataValidationConfig;
+    /** Transformações de dados */
+    transformations?: DataTransformation[];
+    /** Configurações de polling */
+    polling?: PollingConfig;
+}
+interface CacheConfig {
+    /** Habilitar cache */
+    enabled: boolean;
+    /** Tempo de vida do cache (ms) */
+    ttl: number;
+    /** Tamanho máximo do cache */
+    maxSize: number;
+    /** Estratégia de invalidação */
+    invalidationStrategy: 'ttl' | 'manual' | 'on-update';
+}
+interface SyncConfig {
+    /** Sincronização automática */
+    autoSync: boolean;
+    /** Intervalo de sincronização (ms) */
+    interval: number;
+    /** Sincronizar apenas mudanças */
+    deltaSync: boolean;
+    /** Resolver conflitos */
+    conflictResolution: 'client' | 'server' | 'manual';
+}
+interface DataValidationConfig {
+    /** Validação no cliente */
+    clientSide: boolean;
+    /** Validação no servidor */
+    serverSide: boolean;
+    /** Regras de validação */
+    rules?: ValidationRule[];
+    /** Mostrar erros inline */
+    showInlineErrors: boolean;
+}
+interface ValidationRule {
+    /** Campo a validar */
+    field: string;
+    /** Tipo de validação */
+    type: 'required' | 'format' | 'range' | 'custom';
+    /** Parâmetros da validação */
+    params?: any;
+    /** Mensagem de erro */
+    message: string;
+}
+interface DataTransformation {
+    /** ID da transformação */
+    id: string;
+    /** Campo a transformar */
+    field: string;
+    /** Tipo de transformação */
+    type: 'format' | 'calculate' | 'aggregate' | 'custom';
+    /** Função de transformação */
+    transform: string;
+    /** Aplicar na exibição ou nos dados */
+    applyTo: 'display' | 'data' | 'both';
+}
+interface PollingConfig {
+    /** Habilitar polling */
+    enabled: boolean;
+    /** Intervalo de polling (ms) */
+    interval: number;
+    /** Polling apenas quando ativo */
+    onlyWhenActive: boolean;
+    /** Backoff exponencial em caso de erro */
+    exponentialBackoff: boolean;
+}
+interface ThemeConfig {
+    /** Tema principal */
+    primary?: string;
+    /** Tema secundário */
+    secondary?: string;
+    /** Modo escuro */
+    darkMode?: boolean;
+    /** Tema customizado */
+    custom?: {
+        [property: string]: string;
+    };
+    /** Variáveis CSS personalizadas */
+    cssVariables?: {
+        [variable: string]: string;
+    };
+}
+interface PerformanceConfig {
+    /** Configurações de virtualização */
+    virtualization?: VirtualizationConfig;
+    /** Configurações de debounce */
+    debounce?: DebounceConfig;
+    /** Configurações de memória */
+    memory?: MemoryConfig;
+    /** Otimizações de renderização */
+    rendering?: RenderingConfig;
+    /** Lazy loading de recursos */
+    lazyLoading?: LazyLoadingConfig;
+}
+interface DebounceConfig {
+    /** Debounce para busca (ms) */
+    search: number;
+    /** Debounce para filtros (ms) */
+    filter: number;
+    /** Debounce para redimensionamento (ms) */
+    resize: number;
+    /** Debounce para scroll (ms) */
+    scroll: number;
+}
+interface MemoryConfig {
+    /** Máximo de linhas em memória */
+    maxRows: number;
+    /** Limpeza automática */
+    autoCleanup: boolean;
+    /** Intervalo de limpeza (ms) */
+    cleanupInterval: number;
+}
+interface RenderingConfig {
+    /** Usar requestAnimationFrame */
+    useRAF: boolean;
+    /** Batch de updates */
+    batchUpdates: boolean;
+    /** Tamanho do batch */
+    batchSize: number;
+    /** Otimizar re-renders */
+    optimizeReRenders: boolean;
+}
+interface LazyLoadingConfig {
+    /** Lazy loading de imagens */
+    images: boolean;
+    /** Lazy loading de componentes */
+    components: boolean;
+    /** Distância para carregar (px) */
+    threshold: number;
+}
+interface PluginConfig {
+    /** ID único do plugin */
+    id: string;
+    /** Nome do plugin */
+    name: string;
+    /** Versão do plugin */
+    version: string;
+    /** Plugin habilitado */
+    enabled: boolean;
+    /** Configurações específicas do plugin */
+    settings?: any;
+    /** Hooks do plugin */
+    hooks?: {
+        [eventName: string]: string;
+    };
+}
+interface AccessibilityConfig {
+    /** Habilitar recursos de acessibilidade */
+    enabled: boolean;
+    /** Anúncios para screen readers */
+    announcements?: AnnouncementConfig;
+    /** Navegação por teclado */
+    keyboard?: KeyboardAccessibilityConfig;
+    /** Contraste alto */
+    highContrast?: boolean;
+    /** Reduzir movimento */
+    reduceMotion?: boolean;
+    /** Labels ARIA personalizados */
+    ariaLabels?: {
+        [key: string]: string;
+    };
+}
+interface AnnouncementConfig {
+    /** Anunciar mudanças de dados */
+    dataChanges: boolean;
+    /** Anunciar ações do usuário */
+    userActions: boolean;
+    /** Anunciar estados de carregamento */
+    loadingStates: boolean;
+    /** Região live para anúncios */
+    liveRegion: 'polite' | 'assertive';
+}
+interface KeyboardAccessibilityConfig {
+    /** Navegação com Tab */
+    tabNavigation: boolean;
+    /** Navegação com setas */
+    arrowNavigation: boolean;
+    /** Atalhos de teclado */
+    shortcuts: boolean;
+    /** Skip links */
+    skipLinks: boolean;
+    /** Focus trap em modais */
+    focusTrap: boolean;
+}
+/**
+ * Configuração principal da tabela - Nova arquitetura v2.0
+ * Estrutura modular alinhada com as 5 abas do editor
+ * Preparada para crescimento exponencial
+ */
+interface TableConfigV2 {
+    /** Metadados da configuração */
+    meta?: ConfigMetadata;
+    /** Definições de colunas */
+    columns: ColumnDefinition[];
+    /**
+     * Projeção opcional das colunas a partir de `/schemas/filtered`.
+     * Quando habilitada, `columns` é materializado pelo runtime e os overrides
+     * são reaplicados a cada atualização do schema.
+     */
+    columnProjection?: TableSchemaColumnProjectionConfig;
+    /** Comportamento geral da tabela (Aba: Visão Geral & Comportamento) */
+    behavior?: TableBehaviorConfig;
+    /** Configurações de faixa declarativa de KPIs / resumo executivo (Issue #33) */
+    kpiBand?: PraxisKpiBandConfig;
+    /** Configurações de campos computados / propriedades virtuais na ingestão (Issue #34) */
+    computedFields?: PraxisComputedFieldsConfig;
+    /** Configurações de aparência e layout (Aba: Visão Geral & Comportamento) */
+    appearance?: TableAppearanceConfig;
+    /** Barra de ferramentas (Aba: Barra de Ferramentas & Ações) */
+    toolbar?: ToolbarConfig;
+    /** Ações por linha e em lote (Aba: Barra de Ferramentas & Ações) */
+    actions?: TableActionsConfig;
+    /** Configuracoes de IA do runtime da tabela */
+    ai?: TableAiConfig;
+    /** Configurações de exportação (Aba: Barra de Ferramentas & Ações) */
+    export?: ExportConfig;
+    /** Mensagens personalizadas (Aba: Mensagens & Localização) */
+    messages?: MessagesConfig;
+    /** Localização e i18n (Aba: Mensagens & Localização) */
+    localization?: LocalizationConfig;
+    /** Configurações avançadas de dados */
+    data?: DataConfig;
+    /** Temas e customização visual */
+    theme?: ThemeConfig;
+    /** Configurações de performance */
+    performance?: PerformanceConfig;
+    /** Plugins e extensões */
+    plugins?: PluginConfig[];
+    /** Configurações de acessibilidade */
+    accessibility?: AccessibilityConfig;
+    /**
+     * Regras de estilo condicionais aplicadas à linha inteira (escopo global)
+     */
+    rowConditionalStyles?: Array<{
+        condition: JsonLogicExpression | null;
+        /** Referencia semantica versionada; a classe CSS correspondente e privada do runtime. */
+        surfacePresetRef?: {
+            id: string;
+            catalogVersion: string;
+        };
+        /** Efeitos visuais canonicos produzidos pelo editor de regras da Table. */
+        effects?: Array<Record<string, unknown>>;
+        cssClass?: string;
+        style?: {
+            [key: string]: string;
+        };
+        description?: string;
+    }>;
+    /** Regras condicionais de linha para tooltip e animacao derivados de efeitos visuais. */
+    rowConditionalRenderers?: Array<{
+        /** Identificador estável usado para reconciliação e deduplicação de regras authoradas. */
+        id?: string;
+        condition: JsonLogicExpression | null;
+        tooltip?: Record<string, unknown>;
+        animation?: Record<string, unknown>;
+        /** Efeitos visuais canonicos que podem produzir tooltip ou animacao de linha. */
+        effects?: Array<Record<string, unknown>>;
+        description?: string;
+        enabled?: boolean;
+    }>;
+    /** Estado serializado do construtor para regras de linha (round‑trip) */
+    _rowStyleRulesState?: any;
+}
+
+type ValuePresentationType = 'string' | 'number' | 'currency' | 'percentage' | 'date' | 'datetime' | 'time' | 'boolean';
+type ValuePresentationStyle = 'default' | 'short' | 'medium' | 'long' | 'full' | 'compact';
+interface ValuePresentationConfig {
+    type: ValuePresentationType;
+    style?: ValuePresentationStyle;
+    format?: string;
+    currency?: Partial<CurrencyLocaleConfig>;
+    number?: Partial<NumberLocaleConfig>;
+}
+
+/**
+ * Enum que define os tipos de dados (`TYPE`) disponíveis para configuração dos campos de formulário.
+ */
+declare const FieldDataType: {
+    readonly TEXT: "text";
+    readonly NUMBER: "number";
+    readonly EMAIL: "email";
+    readonly DATE: "date";
+    readonly PASSWORD: "password";
+    readonly FILE: "file";
+    readonly URL: "url";
+    readonly BOOLEAN: "boolean";
+    readonly ARRAY: "array";
+    readonly JSON: "json";
+};
+type FieldDataType = typeof FieldDataType[keyof typeof FieldDataType];
+
+/**
+ * Enum que define os tipos de controle (`CONTROL_TYPE`) disponíveis para a apresentação dos campos de formulário.
+ *
+ * O `CONTROL_TYPE` especifica o tipo de elemento de UI (User Interface) que será usado para capturar ou exibir dados do campo.
+ * Essa configuração permite que a camada de apresentação saiba como renderizar o campo e oferecer a interação adequada ao usuário.
+ * Em casos onde o `CONTROL_TYPE` não é especificado, a camada de apresentação pode usar o valor de `TYPE` (definido em `FieldDataType`)
+ * para decidir o controle mais adequado de forma automática.
+ */
+declare const FieldControlType: {
+    readonly AI_PROMPT: "aiPrompt";
+    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";
+    readonly BOTTOM_NAVIGATION: "bottomNavigation";
+    readonly BREADCRUMB: "breadcrumb";
+    readonly BUTTON: "button";
+    readonly BUTTON_TOGGLE: "buttonToggle";
+    readonly CALENDAR: "calendar";
+    readonly CARD: "card";
+    readonly CHECKBOX: "checkbox";
+    readonly CHIP_INPUT: "chipInput";
+    readonly CHIP_LIST: "chipList";
+    readonly CIRCULAR_GAUGE: "circularGauge";
+    readonly COLOR_GRADIENT: "colorGradient";
+    readonly CPF_CNPJ_INPUT: "cpfCnpjInput";
+    readonly COLOR_PALETTE: "colorPalette";
+    readonly COLOR_PICKER: "colorPicker";
+    readonly COLOR_INPUT: "color";
+    readonly CRON_BUILDER: "cronBuilder";
+    readonly CONTEXT_MENU: "contextMenu";
+    readonly CONVERSATIONAL_UI: "conversationalUI";
+    readonly CURRENCY_INPUT: "currency";
+    readonly DATE_INPUT: "dateInput";
+    readonly DATE_PICKER: "date";
+    readonly DATE_RANGE: "dateRange";
+    readonly DATE_TIME_PICKER: "dateTime";
+    readonly DATE_TIME_RANGE: "dateTimeRange";
+    readonly DATETIME_LOCAL_INPUT: "dateTimeLocal";
+    readonly DIALOG: "dialog";
+    readonly DRAWER: "drawer";
+    readonly DROP_DOWN_TREE: "dropDownTree";
+    readonly EMAIL_INPUT: "email";
+    readonly ENTITY_LOOKUP: "entityLookup";
+    readonly EXPANSION_PANEL: "expansionPanel";
+    readonly FILE_SAVER: "fileSaver";
+    readonly FILE_SELECT: "fileSelect";
+    readonly FILE_UPLOAD: "upload";
+    readonly FILTER: "filter";
+    readonly FLOATING_LABEL: "floatingLabel";
+    readonly FLOATING_ACTION_BUTTON: "floatingActionButton";
+    readonly GRID: "grid";
+    readonly GRID_LAYOUT: "gridLayout";
+    readonly INPUT: "input";
+    readonly INLINE_SELECT: "inlineSelect";
+    readonly INLINE_SEARCHABLE_SELECT: "inlineSearchableSelect";
+    readonly INLINE_ASYNC_SELECT: "inlineAsyncSelect";
+    readonly INLINE_ENTITY_LOOKUP: "inlineEntityLookup";
+    readonly INLINE_AUTOCOMPLETE: "inlineAutocomplete";
+    readonly INLINE_INPUT: "inlineInput";
+    readonly INLINE_PHONE: "inlinePhone";
+    readonly INLINE_NUMBER: "inlineNumber";
+    readonly INLINE_CURRENCY: "inlineCurrency";
+    readonly INLINE_CURRENCY_RANGE: "inlineCurrencyRange";
+    readonly INLINE_MULTISELECT: "inlineMultiSelect";
+    readonly INLINE_TOGGLE: "inlineToggle";
+    readonly INLINE_RANGE: "inlineRange";
+    readonly INLINE_PERIOD_RANGE: "inlinePeriodRange";
+    readonly INLINE_YEAR_RANGE: "inlineYearRange";
+    readonly INLINE_MONTH_RANGE: "inlineMonthRange";
+    readonly INLINE_DATE: "inlineDate";
+    readonly INLINE_DATE_RANGE: "inlineDateRange";
+    readonly INLINE_TIME: "inlineTime";
+    readonly INLINE_TIME_RANGE: "inlineTimeRange";
+    readonly INLINE_TREE_SELECT: "inlineTreeSelect";
+    readonly INLINE_RATING: "inlineRating";
+    readonly INLINE_DISTANCE_RADIUS: "inlineDistanceRadius";
+    readonly INLINE_PIPELINE_STATUS: "inlinePipelineStatus";
+    readonly INLINE_SCORE_PRIORITY: "inlineScorePriority";
+    readonly INLINE_RELATIVE_PERIOD: "inlineRelativePeriod";
+    readonly INLINE_SENTIMENT: "inlineSentiment";
+    readonly INLINE_COLOR_LABEL: "inlineColorLabel";
+    readonly LINEAR_GAUGE: "linearGauge";
+    readonly LIST_VIEW: "listView";
+    readonly MAP: "map";
+    readonly MASKED_TEXT_BOX: "maskedTextBox";
+    readonly MONTH_INPUT: "month";
+    readonly MULTI_COLUMN_COMBO_BOX: "multiColumnComboBox";
+    readonly MULTI_SELECT: "multiSelect";
+    readonly MULTI_SELECT_TREE: "multiSelectTree";
+    readonly TRANSFER_LIST: "transferList";
+    readonly NOTIFICATION: "notification";
+    readonly NUMERIC_TEXT_BOX: "numericTextBox";
+    readonly PAGER: "pager";
+    readonly PAGINATOR: "paginator";
+    readonly PASSWORD: "password";
+    readonly PDF_VIEWER: "pdfViewer";
+    readonly PHONE: "phone";
+    readonly PIVOT_GRID: "pivotGrid";
+    readonly POPUP: "popup";
+    readonly PROGRESS_BAR: "progressBar";
+    readonly PROGRESS_SPINNER: "progressSpinner";
+    readonly QR_CODE: "qrCode";
+    readonly RADIO: "radio";
+    readonly RADIAL_GAUGE: "radialGauge";
+    readonly RANGE_SLIDER: "rangeSlider";
+    readonly PRICE_RANGE: "priceRange";
+    readonly RATING: "rating";
+    readonly RICH_TEXT_EDITOR: "richTextEditor";
+    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";
+    readonly SLIDER: "slider";
+    readonly SORTABLE: "sortable";
+    readonly SORTABLE_TABLE: "sortableTable";
+    readonly SPLITTER: "splitter";
+    readonly SPREADSHEET: "spreadsheet";
+    readonly STACK_LAYOUT: "stackLayout";
+    readonly STEP_BAR: "stepBar";
+    readonly STEPPER: "stepper";
+    readonly SVG_ICON: "svgIcon";
+    readonly TABS: "tabs";
+    readonly TEXTAREA: "textarea";
+    readonly TIME_INPUT: "time";
+    readonly TIME_PICKER: "timePicker";
+    readonly TIME_RANGE: "timeRange";
+    readonly TIMELINE: "timeline";
+    readonly TOGGLE: "toggle";
+    readonly TOOLBAR: "toolbar";
+    readonly TOOLTIP: "tooltip";
+    readonly TREE_VIEW: "treeView";
+    readonly TREE_SELECT: "treeSelect";
+    readonly TYPOGRAPHY: "typography";
+    readonly URL_INPUT: "url";
+    readonly WEEK_INPUT: "week";
+    readonly WINDOW: "window";
+    readonly YEAR_INPUT: "year";
+};
+type FieldControlType = (typeof FieldControlType)[keyof typeof FieldControlType];
+
+type FormFieldHelpDisplay = 'auto' | 'inline' | 'popover' | 'hidden';
+
+/**
+ * @fileoverview Base metadata interfaces for dynamic Angular Material components
+ *
+ * This file implements a hierarchical system of metadata interfaces designed for
+ * maximum flexibility, type safety, and Angular Material integration.
+ *
+ * Architecture:
+ * - ComponentMetadata (universal base)
+ * - FieldMetadata (form fields)
+ * - Specialized interfaces (MaterialInput, MaterialSelect, etc.)
+ *
+ * Design Principles:
+ * - Configuration over Code
+ * - JSON serializable
+ * - Type-safe with strict TypeScript
+ * - Backward compatible
+ * - Angular Material 3 native support
+ */
+
+/**
+ * Universal base interface for all dynamic components.
+ *
+ * Provides maximum extensibility through index signature while maintaining
+ * essential metadata properties for component lifecycle management.
+ *
+ * @example
+ * ```typescript
+ * const buttonMetadata: ComponentMetadata = {
+ *   id: 'submit-btn',
+ *   version: '1.0.0',
+ *   context: 'form',
+ *   customProperty: 'any value'
+ * };
+ * ```
+ */
+interface ComponentMetadata {
+    /** Unique identifier for the component instance */
+    id?: string;
+    /** Metadata schema version for migration support */
+    version?: string;
+    /** Application context where component is used */
+    context?: 'form' | 'filter' | 'table' | 'dialog' | 'standalone';
+    /** Timestamp when metadata was created */
+    createdAt?: string;
+    /** Timestamp when metadata was last updated */
+    updatedAt?: string;
+    /** Tags for categorization and filtering */
+    tags?: string[];
+    /** Custom CSS classes to apply to the component */
+    cssClass?: string;
+    /** Inline styles as CSS properties object */
+    style?: Record<string, string>;
+    /** Data attributes for testing or analytics */
+    dataAttributes?: Record<string, string>;
+    /** Extensibility: allow any additional properties */
+    [key: string]: any;
+}
+/**
+ * Enhanced validation configuration for comprehensive field validation.
+ *
+ * Supports both built-in Angular validators and custom validation logic
+ * with internationalization support for error messages.
+ */
+interface ValidatorOptions {
+    /** Field is required */
+    required?: boolean;
+    /** Custom message for required validation */
+    requiredMessage?: string;
+    /** Minimum text length */
+    minLength?: number;
+    /** Custom message for minLength validation */
+    minLengthMessage?: string;
+    /** Maximum text length */
+    maxLength?: number;
+    /** Custom message for maxLength validation */
+    maxLengthMessage?: string;
+    /** Minimum numeric value */
+    min?: number;
+    /** Custom message for min validation */
+    minMessage?: string;
+    /** Maximum numeric value */
+    max?: number;
+    /** Custom message for max validation */
+    maxMessage?: string;
+    /** RegExp pattern for validation */
+    pattern?: string | RegExp;
+    /** Custom message for pattern validation */
+    patternMessage?: string;
+    /** Custom message for legacy CPF validation */
+    cpfMessage?: string;
+    /** Custom message for legacy CNPJ validation */
+    cnpjMessage?: string;
+    /** Custom message for alphanumeric CNPJ validation */
+    cnpjAlphaMessage?: string;
+    /** Built-in legacy CPF validation */
+    cpf?: boolean;
+    /** Built-in legacy CNPJ validation */
+    cnpj?: boolean;
+    /** Built-in auto-detect CPF/CNPJ validation */
+    cpfCnpj?: boolean;
+    /** Built-in alphanumeric CNPJ validation */
+    cnpjAlpha?: boolean;
+    /** Built-in email validation */
+    email?: boolean;
+    /** Custom message for email validation */
+    emailMessage?: string;
+    /** Built-in URL validation */
+    url?: boolean;
+    /** Custom message for URL validation */
+    urlMessage?: string;
+    /** Minimum number of words for text content */
+    minWords?: number;
+    /** Require checkbox to be checked (for checkbox fields) */
+    requiredChecked?: boolean;
+    /** Custom synchronous validator function */
+    customValidator?: (value: any, context?: any) => boolean | string | null;
+    /** Custom asynchronous validator function */
+    asyncValidator?: (value: any, context?: any) => Promise<boolean | string | null>;
+    /** Cross-field validation - must match another field */
+    matchField?: string;
+    /** Custom message for field matching validation */
+    matchFieldMessage?: string;
+    /** Unique value validation via API call */
+    uniqueValidator?: (value: any) => Promise<boolean>;
+    /** Custom message for unique validation */
+    uniqueMessage?: string;
+    /** Conditional validation rules driven by canonical Json Logic. */
+    conditionalValidation?: ConditionalValidationRule[];
+    /** When to trigger validation */
+    validationTrigger?: 'change' | 'blur' | 'submit' | 'immediate';
+    /** Debounce time for validation in milliseconds */
+    validationDebounce?: number;
+    /** Show validation errors inline */
+    showInlineErrors?: boolean;
+    /** Custom error display position */
+    errorPosition?: 'bottom' | 'top' | 'tooltip';
+}
+interface ConditionalValidationRule {
+    /** Canonical Json Logic guard evaluated against the `form` root. */
+    condition: JsonLogicExpression | null;
+    /** Validators applied when the guard resolves to true. */
+    validators: Omit<ValidatorOptions, 'conditionalValidation'>;
+}
+interface FieldArrayOperations {
+    add?: boolean;
+    edit?: boolean;
+    remove?: boolean;
+    [key: string]: any;
+}
+interface FieldArrayCollectionValidation {
+    uniqueBy?: string[];
+    exactlyOne?: {
+        field: string;
+        value?: any;
+        message?: string;
+    };
+    atLeastOne?: {
+        field: string;
+        value?: any;
+        message?: string;
+    };
+    sumEquals?: {
+        field: string;
+        targetField?: string;
+        value?: number;
+        message?: string;
+    };
+    [key: string]: any;
+}
+interface FieldArrayConfig {
+    itemType?: 'object';
+    mode?: 'cards';
+    itemSchemaRef?: string;
+    itemIdentityField?: string;
+    minItems?: number;
+    maxItems?: number;
+    addLabel?: string;
+    emptyState?: string;
+    itemTitleTemplate?: string;
+    operations?: FieldArrayOperations;
+    deleteMode?: 'removeFromPayload';
+    itemSchema?: {
+        fields?: FieldMetadata[];
+        properties?: Record<string, any>;
+        [key: string]: any;
+    };
+    collectionValidation?: FieldArrayCollectionValidation;
+    [key: string]: any;
+}
+/**
+ * Configuration for field options in selection components.
+ *
+ * Supports both static arrays and dynamic loading from APIs
+ * with flexible data transformation capabilities.
+ */
+interface FieldOption {
+    /** The actual value to be stored */
+    value: any;
+    /** Display text shown to user */
+    text: string;
+    /** Optional grouping for organized display */
+    group?: string;
+    /** Whether this option is disabled */
+    disabled?: boolean;
+    /** Additional data associated with option */
+    data?: any;
+    /** CSS class for styling */
+    cssClass?: string;
+    /** Alternative CSS class property name */
+    class?: string;
+    /** Icon to display with option */
+    icon?: string;
+    /** Tooltip text for option */
+    tooltip?: string;
+    /** Detailed description for the option */
+    description?: string;
+}
+/**
+ * Angular Material specific styling and behavior options.
+ *
+ * Covers appearance, theming, density, and interaction patterns
+ * specific to Material Design 3 components.
+ */
+interface MaterialDesignConfig {
+    /** Material appearance variant */
+    appearance?: 'fill' | 'outline';
+    /** Material color theme */
+    color?: 'primary' | 'accent' | 'warn';
+    /** Label floating behavior */
+    floatLabel?: 'auto' | 'always';
+    /** Subscript sizing strategy */
+    subscriptSizing?: 'fixed' | 'dynamic';
+    /** Hide required marker asterisk */
+    hideRequiredMarker?: boolean;
+    /** Component density */
+    density?: 'comfortable' | 'compact' | 'dense';
+    /** Disable ripple effects */
+    disableRipple?: boolean;
+    /** Custom theme palette override */
+    customPalette?: {
+        primary?: string;
+        accent?: string;
+        warn?: string;
+    };
+    /** Animation configuration */
+    animations?: {
+        disabled?: boolean;
+        duration?: number;
+        easing?: string;
+    };
+}
+type InlineOverlayApplyMode = 'auto' | 'explicit';
+type InlineOverlayActionAppearance = 'text' | 'filled' | 'outlined' | 'tonal';
+type InlineOverlayActionColorRole = 'primary' | 'secondary' | 'neutral' | 'danger';
+interface InlineOverlayActionMetadata {
+    /** Visible action label. Falls back to component i18n when omitted. */
+    label?: string;
+    /** Accessible label for context-rich action buttons. */
+    ariaLabel?: string;
+    /** Theme-driven visual style. */
+    appearance?: InlineOverlayActionAppearance;
+    /** Semantic color role resolved through theme tokens. */
+    colorRole?: InlineOverlayActionColorRole;
+    /** Optional Material Symbols icon name. */
+    icon?: string;
+    /** Allows authoring surfaces to hide an action without deleting its config. */
+    visible?: boolean;
+}
+interface InlineOverlayActionsMetadata {
+    apply?: InlineOverlayActionMetadata;
+    cancel?: InlineOverlayActionMetadata;
+    clear?: InlineOverlayActionMetadata;
+}
+interface InlineOverlayMetadata {
+    /**
+     * Commit mode for editable inline overlays:
+     * - `auto`: changes commit immediately.
+     * - `explicit`: edits stay as draft until the apply action.
+     */
+    applyMode?: InlineOverlayApplyMode;
+    /** Theme-aware metadata for footer actions. */
+    actions?: InlineOverlayActionsMetadata;
+}
+/**
+ * Comprehensive metadata interface for form fields.
+ *
+ * This is the main interface that extends ComponentMetadata with field-specific
+ * properties covering behavior, validation, data binding, and UI configuration.
+ *
+ * @example
+ * ```typescript
+ * const emailField: FieldMetadata = {
+ *   name: 'email',
+ *   label: 'Email Address',
+ *   controlType: 'input',
+ *   required: true,
+ *   validators: {
+ *     required: true,
+ *     email: true,
+ *     requiredMessage: 'Email is required',
+ *     emailMessage: 'Please enter a valid email'
+ *   },
+ *   materialDesign: {
+ *     appearance: 'outline',
+ *     color: 'primary'
+ *   }
+ * };
+ * ```
+ */
+type FieldSource = 'schema' | 'local';
+type FieldSubmitPolicy = 'include' | 'omit' | 'includeWhenDirty';
+interface FieldMetadata extends ComponentMetadata {
+    /** Unique field identifier (required) */
+    name: string;
+    /** Display label for the field */
+    label: string;
+    /**
+     * Indicates that `label` was generated automatically by infrastructure code
+     * such as schema mappers, instead of being authored explicitly by metadata.
+     *
+     * This flag is optional and defaults to `false` when omitted, preserving
+     * backward compatibility for existing serialized metadata and host contracts.
+     *
+     * Intended use:
+     * - allow authoring/runtime layers to distinguish domain text from fallback UI
+     * - support governance checks that require explicit labels in enterprise flows
+     * - avoid relying on implicit casts such as `(fieldMetadata as any)`
+     */
+    labelAutoGenerated?: boolean;
+    /** Field control type for component resolution */
+    controlType: FieldControlType;
+    /** Data type for processing and validation */
+    dataType?: FieldDataType;
+    /** Canonical metadata for editable collection fields (`controlType: "array"`). */
+    array?: FieldArrayConfig;
+    /** Optional top-level alias for collection validators mirrored into `array.collectionValidation`. */
+    collectionValidation?: FieldArrayCollectionValidation;
+    /** Display order in form */
+    order?: number;
+    /** Logical grouping of related fields */
+    group?: string;
+    /** Detailed description for tooltips */
+    description?: string;
+    /**
+     * Field origin for metadata-driven forms.
+     *
+     * Defaults to `schema` when omitted. Use `local` for host-authored fields that
+     * support the form UX but do not belong to the backend DTO/schema.
+     */
+    source?: FieldSource;
+    /**
+     * Marks a field as form-local/transient.
+     *
+     * Transient fields participate in validation, rules, visibility, and value
+     * changes, but are omitted from submit payloads unless `submitPolicy` is
+     * explicitly set to `include`.
+     */
+    transient?: boolean;
+    /**
+     * Submit behavior for the field.
+     *
+     * Defaults to `omit` for local/transient fields and `include` for schema
+     * fields. When provided, this value has priority over `source` and
+     * `transient`.
+     */
+    submitPolicy?: FieldSubmitPolicy;
+    /** Field is required */
+    required?: boolean;
+    /** Field is disabled */
+    disabled?: boolean;
+    /** Field is read-only */
+    readOnly?: boolean;
+    /**
+     * Canonical backend-authored access metadata for field-level UX materialization.
+     *
+     * The frontend may use this contract to hide or lock controls for usability,
+     * but it is not a security boundary. Backend filtering and validation remain
+     * the final authority for sensitive data.
+     */
+    fieldAccess?: FieldAccessMetadata;
+    /** Field is hidden from display */
+    hidden?: boolean;
+    /** Canonical conditional visibility guard for metadata-driven forms. */
+    hiddenCondition?: JsonLogicExpression | null;
+    /** Default value when form initializes */
+    defaultValue?: any;
+    /** Placeholder text for empty fields */
+    placeholder?: string;
+    /** Help text displayed below field */
+    hint?: string;
+    /** Domain help text emitted by backend schema metadata. */
+    helpText?: string;
+    /** Effective help presentation resolved by the form host. */
+    helpDisplay?: FormFieldHelpDisplay;
+    /** Field-level inline threshold used when `helpDisplay` is `auto`. */
+    helpInlineMaxLength?: number;
+    /** Tooltip text on hover */
+    tooltip?: string;
+    /** Enables hover tooltip presentation when supported by the field renderer. */
+    tooltipOnHover?: boolean;
+    /** Semantic selection mode for boolean/single/multiple choice controls */
+    selectionMode?: 'boolean' | 'single' | 'multiple';
+    /** Visual variant used by controls with more than one supported presentation */
+    variant?: string;
+    /** Comprehensive validation rules */
+    validators?: ValidatorOptions;
+    /** When to validate field changes */
+    validationMode?: 'immediate' | 'blur' | 'submit';
+    /** Debounce time for validation (ms) */
+    debounceTime?: number;
+    /** Validate uniqueness via API */
+    unique?: boolean;
+    /** Static options for selection fields */
+    options?: FieldOption[];
+    /** API endpoint for dynamic data loading */
+    endpoint?: string;
+    /** Canonical backend resource path for metadata-driven requests */
+    resourcePath?: string;
+    /** Canonical metadata-driven source for derived options */
+    optionSource?: OptionSourceMetadata;
+    /** Field name for option values */
+    valueField?: string;
+    /** Field name for option display text */
+    displayField?: string;
+    /** Field name for option filtering */
+    filterField?: string;
+    /** Additional query parameters for API calls */
+    queryParams?: Record<string, any>;
+    /** Cache duration for remote data (ms) */
+    cacheDuration?: number;
+    /** Field width specification */
+    width?: string | number;
+    /** Use flexbox sizing */
+    isFlex?: boolean;
+    /** Icons configuration */
+    prefixIcon?: string;
+    suffixIcon?: string;
+    iconPosition?: 'start' | 'end';
+    iconSize?: 'small' | 'medium' | 'large';
+    iconColor?: string;
+    iconClass?: string;
+    iconStyle?: string;
+    iconFontSize?: string | number;
+    /** 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 */
+    format?: string;
+    /**
+     * Canonical value-presentation semantics used by read-only/display surfaces.
+     *
+     * When provided, this metadata should be preferred over legacy formatting
+     * hints such as `format`, `currency`, `locale`, or control-specific
+     * heuristics.
+     */
+    valuePresentation?: ValuePresentationConfig;
+    /**
+     * Semantic presentation metadata for read-only/display surfaces.
+     *
+     * Consumers map this contract to their own theme tokens and primitives. It
+     * intentionally avoids arbitrary CSS, HTML, or mutation commands.
+     */
+    presentation?: FieldPresentationConfig;
+    /**
+     * Ordered Json Logic rules that conditionally override `presentation` in
+     * readonly/display surfaces. Later matching rules win.
+     */
+    presentationRules?: FieldPresentationRule[];
+    /** Material Design specific configuration */
+    materialDesign?: MaterialDesignConfig;
+    /**
+     * Shared contract for editable inline overlays.
+     *
+     * Use when the component opens a panel/popover with draftable edits and
+     * needs platform-governed Apply/Cancel/Clear actions.
+     */
+    inlineOverlay?: InlineOverlayMetadata;
+    /** Fields this field depends on */
+    dependencyFields?: string[];
+    /** Canonical conditional required guard for metadata-driven forms. */
+    conditionalRequired?: JsonLogicExpression | null;
+    /** Canonical conditional visibility guard for metadata-driven forms. */
+    conditionalDisplay?: JsonLogicExpression | null;
+    /** Reset value when dependency changes */
+    resetOnDependentChange?: boolean;
+    /** Enable native field-to-field dependency cascade inside the same form */
+    enableDependencyCascade?: boolean;
+    /**
+     * Map dependent field name -> backend filter key or { key, valuePath }
+     * Supports dot-path in 'key' to build nested filter objects
+     */
+    dependencyFilterMap?: Record<string, string | {
+        key: string;
+        valuePath?: string;
+    }>;
+    /** Value path for extracting the dependent value (string or per-field map) */
+    dependencyValuePath?: string | Record<string, string>;
+    /** Debounce (ms) applied to combined dependencies */
+    dependencyDebounceMs?: number;
+    /** How to merge calculated fragment: 'replace' | 'merge' */
+    dependencyMergeStrategy?: 'replace' | 'merge';
+    /** When to reload on dependency change */
+    dependencyLoadOnChange?: 'respectLoadOn' | 'immediate' | 'manual';
+    /** Optional: suppress inline errors briefly when cascade resets value */
+    suppressInlineErrorsOnCascade?: boolean;
+    /** Allow inline editing in tables */
+    inlineEditing?: boolean;
+    /** Transform value before display */
+    transformDisplayValue?: (value: any) => any;
+    /** Transform value before saving */
+    transformSaveValue?: (value: any) => any;
+    /** Where to apply optional text transformation (editor setting) */
+    textTransformApply?: 'displayOnly' | 'saveOnly' | 'both';
+    /** Contexts where field should be visible */
+    visibleIn?: Array<'form' | 'filter' | 'table' | 'dialog'>;
+    /** Hide in specific form contexts */
+    formHidden?: boolean;
+    /** Hide in table contexts */
+    tableHidden?: boolean;
+    /** Hide in filter contexts */
+    filterHidden?: boolean;
+    /** ARIA label for screen readers */
+    ariaLabel?: string;
+    /** ARIA described by element IDs */
+    ariaDescribedBy?: string;
+    /** Tab index for keyboard navigation */
+    tabIndex?: number;
+    /** Keyboard shortcuts */
+    accessKey?: string;
+}
+
+interface FieldAccessMetadata {
+    visibleForAuthorities?: string[];
+    editableForAuthorities?: string[];
+    reason?: string;
+}
+
+/**
+ * Contrato de saída do normalizador de esquema (SchemaNormalizerService):
+ * - Converte metadados `x-ui` em FieldDefinition tipado.
+ * - Condições booleanas declarativas serializáveis usam Json Logic canônico:
+ *   - conditionalDisplay: JsonLogicExpression | null
+ *   - conditionalRequired: JsonLogicExpression | null
+ *   - 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;
+    selectionMode?: 'boolean' | 'single' | 'multiple';
+    variant?: string;
+    density?: 'compact' | 'comfortable' | 'spacious';
+    layout?: 'horizontal' | 'vertical';
+    disabled?: boolean;
+    readOnly?: boolean;
+    fieldAccess?: FieldAccessMetadata;
+    array?: FieldArrayConfig;
+    collectionValidation?: FieldArrayCollectionValidation;
+    multiple?: boolean;
+    editable?: boolean;
+    validationMode?: string;
+    unique?: boolean;
+    mask?: string;
+    sortable?: boolean;
+    /** Json Logic canônico que define obrigatoriedade condicional. */
+    conditionalRequired?: JsonLogicExpression | null;
+    viewOnlyStyle?: string;
+    /** Lista de gatilhos de validação, ex.: ["blur", "change"]. */
+    validationTriggers?: string[];
+    hidden?: boolean;
+    tableHidden?: boolean;
+    formHidden?: boolean;
+    filterable?: boolean;
+    /** Json Logic canônico que controla se o campo é exibido. */
+    conditionalDisplay?: JsonLogicExpression | null;
+    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?: JsonLogicExpression | null;
+    tooltip?: string;
+    tooltipOnHover?: boolean;
+    icon?: string;
+    iconPosition?: string;
+    iconSize?: string | number;
+    iconColor?: string;
+    iconClass?: string;
+    iconStyle?: string;
+    iconFontSize?: string | number;
+    valueField?: string;
+    displayField?: string;
+    filterField?: string;
+    endpoint?: string;
+    resourcePath?: string;
+    optionSource?: OptionSourceMetadata;
+    emptyOptionText?: string;
+    options?: {
+        key: string;
+        value: string;
+        label?: string;
+        [key: string]: any;
+    }[];
+    filter?: any;
+    filterCriteria?: any;
+    searchable?: boolean;
+    selectAll?: boolean;
+    maxSelections?: number;
+    optionLabelKey?: string;
+    optionValueKey?: string;
+    filterOptions?: any[];
+    numericFormat?: string;
+    valuePresentation?: ValuePresentationConfig;
+    /** Semantic read-only/list presentation metadata from canonical x-ui.presentation. */
+    presentation?: FieldPresentationConfig;
+    /** Conditional presentation overrides for read-only/list consumers. */
+    presentationRules?: FieldPresentationRule[];
+    numericStep?: number;
+    numericMin?: number;
+    numericMax?: number;
+    numericMaxLength?: number;
+    optionGroups?: {
+        key: string;
+        value: string;
+        label?: string;
+        [key: string]: any;
+    }[];
+    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;
+    /** Regras declarativas de validação condicional baseadas no root `form`. */
+    conditionalValidation?: ConditionalValidationRule[];
+    /** 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;
+}
+
+/** Normalizes the exact schema/root object using the canonical Core calculation.
+ * The caller must admit source, content and execution before invoking this function:
+ * declared function expressions may execute during field construction.
+ * This performs neither strict JSON parsing nor provenance/schema admission.
+ */
+declare function normalizeSchemaFields(schema: unknown): FieldDefinition[];
+
+/**
+ * Deep merge that prefers values from `right` when defined.
+ * - Objects are merged recursively
+ * - Arrays are replaced by `right` when defined
+ * - Primitive `undefined` on right keeps left's value
+ */
+declare function deepMerge<T>(left: T, right: Partial<T> | undefined): T;
+
+declare function resolveColumnTypeFromFieldDefinition(def: FieldDefinition, fallback?: ColumnDefinition['type']): ColumnDefinition['type'] | undefined;
+declare function resolveTextMaskFormatFromFieldDefinition(def: FieldDefinition): string | undefined;
+
+type TableConfig = TableConfigV2;
+
+export { deepMerge, isPraxisPresentationVisualizationTableSafe, normalizeSchemaFields, resolveColumnTypeFromFieldDefinition, resolveTextMaskFormatFromFieldDefinition };
+export type { ColumnDefinition, FieldDefinition, TableConfig };