@praxisui/core 10.0.0-rc.3 → 10.0.0-rc.5

package/fesm2022/praxisui-core-schema.mjs

@@ -0,0 +1,2946 @@
+function normalizeFieldAccessMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const source = value;
+    const visibleForAuthorities = normalizeAuthorityList(source['visibleForAuthorities']);
+    const editableForAuthorities = normalizeAuthorityList(source['editableForAuthorities']);
+    const reason = typeof source['reason'] === 'string' && source['reason'].trim()
+        ? source['reason'].trim()
+        : undefined;
+    if (!visibleForAuthorities && !editableForAuthorities) {
+        return undefined;
+    }
+    return {
+        ...(visibleForAuthorities ? { visibleForAuthorities } : {}),
+        ...(editableForAuthorities ? { editableForAuthorities } : {}),
+        ...(reason ? { reason } : {}),
+    };
+}
+function evaluateFieldAccess(fieldOrAccess, context = {}) {
+    const fieldAccess = normalizeFieldAccessMetadata(isFieldAccessMetadata(fieldOrAccess)
+        ? fieldOrAccess
+        : fieldOrAccess?.fieldAccess);
+    if (!fieldAccess) {
+        return { evaluated: false, visible: true, editable: true };
+    }
+    const authorities = normalizeAuthoritySet(context.authorities);
+    if (!authorities) {
+        return {
+            evaluated: false,
+            visible: true,
+            editable: true,
+            ...(fieldAccess.reason ? { reason: fieldAccess.reason } : {}),
+        };
+    }
+    const hasExplicitEditablePolicy = !!fieldAccess.editableForAuthorities?.length;
+    const editableAllowed = hasExplicitEditablePolicy
+        ? matchesAuthority(fieldAccess.editableForAuthorities, authorities)
+        : false;
+    const visibleAllowed = matchesAuthority(fieldAccess.visibleForAuthorities, authorities) ||
+        editableAllowed;
+    return {
+        evaluated: true,
+        visible: visibleAllowed,
+        editable: editableAllowed || !hasExplicitEditablePolicy,
+        ...(fieldAccess.reason ? { reason: fieldAccess.reason } : {}),
+    };
+}
+function isFieldAccessMetadata(value) {
+    return !!value && ('visibleForAuthorities' in value ||
+        'editableForAuthorities' in value ||
+        'reason' in value);
+}
+function normalizeAuthorityList(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const normalized = Array.from(new Set(value
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.trim())
+        .filter(Boolean)));
+    return normalized.length ? normalized : undefined;
+}
+function normalizeAuthoritySet(authorities) {
+    if (!Array.isArray(authorities)) {
+        return null;
+    }
+    return new Set(authorities
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.trim())
+        .filter(Boolean));
+}
+function matchesAuthority(required, actual) {
+    if (!required || required.length === 0) {
+        return true;
+    }
+    return required.some((authority) => actual.has(authority));
+}
+
+const VISUALIZATION_KINDS = new Set([
+    'line',
+    'area',
+    'column',
+    'comparison',
+    'stackedBar',
+    'radial',
+    'harveyBall',
+    'bullet',
+    'delta',
+    'processFlow',
+]);
+const VISUALIZATION_SURFACES = new Set([
+    'table-cell',
+    'list-item',
+    'object-header',
+    'card-summary',
+    'form-presentation',
+]);
+const VISUALIZATION_SIZES = new Set([
+    'xs',
+    'sm',
+    'md',
+    'lg',
+    'responsive',
+]);
+const VISUALIZATION_TONES = new Set([
+    'neutral',
+    'info',
+    'success',
+    'warning',
+    'danger',
+    'critical',
+]);
+const TABLE_SAFE_KINDS = new Set([
+    'line',
+    'area',
+    'column',
+    'comparison',
+    'stackedBar',
+    'radial',
+    'harveyBall',
+    'bullet',
+    'delta',
+    'processFlow',
+]);
+const TABLE_CELL_RECOMMENDED_KINDS = new Set([
+    'delta',
+    'bullet',
+    'radial',
+    'harveyBall',
+    'stackedBar',
+]);
+/**
+ * Returns the compact-table suitability of a supported visualization kind.
+ * Trend and workflow-heavy kinds are conditional because they require enough
+ * column width and a clear decision-making purpose to remain legible.
+ */
+function getPraxisTableCellVisualizationGuidance(kind) {
+    return TABLE_CELL_RECOMMENDED_KINDS.has(kind) ? 'recommended' : 'conditional';
+}
+function getPraxisTableCellVisualizationConstraint(kind) {
+    if (kind === 'comparison')
+        return 'row-density';
+    if (kind === 'processFlow')
+        return 'step-labels';
+    if (kind === 'line' || kind === 'area' || kind === 'column') {
+        return 'horizontal-space';
+    }
+    return null;
+}
+/**
+ * Resolucao pura e canonica de tom semantico e rotulo acessivel para micro-visualizacoes.
+ *
+ * Precedencia de avaliacao:
+ * 1. Correspondencia discreta (`equals`), tolerante a numeros e strings.
+ * 2. Faixa numerica continua (`min` e `max`, inclusiva).
+ * 3. Faixa aberta a direita (`min` ate infinito).
+ * 4. Faixa aberta a esquerda (menos infinito ate `max`).
+ * 5. Limiar de corte progressivo (`value`).
+ * 6. Fallback estatico (`fallbackTone`).
+ */
+function resolvePraxisMicroVisualizationTone(value, thresholds, fallbackTone) {
+    if (value === undefined || value === null || !Array.isArray(thresholds) || thresholds.length === 0) {
+        return fallbackTone ? { tone: fallbackTone } : undefined;
+    }
+    const num = typeof value === 'number' ? value : Number(value);
+    const isNum = Number.isFinite(num);
+    // 1. Pass 1: Correspondencia discreta (equals) tem prioridade maxima
+    for (const t of thresholds) {
+        if (!t || !t.tone || t.equals === undefined) {
+            continue;
+        }
+        if (t.equals === value || String(t.equals) === String(value)) {
+            return { tone: t.tone, label: t.label, matchedThreshold: t };
+        }
+        if (isNum && Number.isFinite(Number(t.equals)) && Number(t.equals) === num) {
+            return { tone: t.tone, label: t.label, matchedThreshold: t };
+        }
+    }
+    // 2. Pass 2: Faixas continuas ou limiares de corte
+    if (isNum) {
+        for (const t of thresholds) {
+            if (!t || !t.tone) {
+                continue;
+            }
+            const hasMin = t.min !== undefined && Number.isFinite(t.min);
+            const hasMax = t.max !== undefined && Number.isFinite(t.max);
+            if (hasMin && hasMax) {
+                if (num >= t.min && num <= t.max) {
+                    return { tone: t.tone, label: t.label, matchedThreshold: t };
+                }
+            }
+            else if (hasMin) {
+                if (num >= t.min) {
+                    return { tone: t.tone, label: t.label, matchedThreshold: t };
+                }
+            }
+            else if (hasMax) {
+                if (num <= t.max) {
+                    return { tone: t.tone, label: t.label, matchedThreshold: t };
+                }
+            }
+            else if (t.value !== undefined && Number.isFinite(t.value) && num >= t.value) {
+                return { tone: t.tone, label: t.label, matchedThreshold: t };
+            }
+        }
+    }
+    return fallbackTone ? { tone: fallbackTone } : undefined;
+}
+function normalizePraxisPresentationVisualization(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const kind = normalizeEnum$1(value.kind, VISUALIZATION_KINDS);
+    const fallbackText = normalizeText$1(value.fallbackText);
+    if (!kind || !fallbackText) {
+        return undefined;
+    }
+    const surface = normalizeEnum$1(value.surface, VISUALIZATION_SURFACES);
+    const size = normalizeEnum$1(value.size, VISUALIZATION_SIZES);
+    const tone = normalizeEnum$1(value.tone, VISUALIZATION_TONES);
+    const ariaLabel = normalizeText$1(value.ariaLabel);
+    const valueSuffix = normalizeText$1(value.valueSuffix);
+    const thresholdsObj = normalizeThresholds(value.thresholds);
+    let resolvedTone = tone;
+    let resolvedAriaLabel = ariaLabel;
+    if (!resolvedTone && thresholdsObj?.thresholds?.length) {
+        let evalVal = value.value;
+        if (evalVal === undefined && Array.isArray(value.points) && value.points.length > 0) {
+            const last = value.points[value.points.length - 1];
+            if (last && typeof last === 'object' && Number.isFinite(last.value)) {
+                evalVal = last.value;
+            }
+        }
+        else if (Array.isArray(evalVal) && evalVal.length > 0) {
+            const last = evalVal[evalVal.length - 1];
+            evalVal = typeof last === 'object' && last !== null && 'value' in last ? last.value : last;
+        }
+        if (evalVal !== undefined && evalVal !== null) {
+            const resolution = resolvePraxisMicroVisualizationTone(evalVal, thresholdsObj.thresholds);
+            if (resolution?.tone) {
+                resolvedTone = resolution.tone;
+            }
+            if (resolution?.label && !resolvedAriaLabel) {
+                resolvedAriaLabel = `${fallbackText}: ${resolution.label}`;
+            }
+        }
+    }
+    return {
+        kind,
+        fallbackText,
+        ...(surface ? { surface } : {}),
+        ...(size ? { size } : {}),
+        ...(resolvedTone ? { tone: resolvedTone } : {}),
+        ...(resolvedAriaLabel ? { ariaLabel: resolvedAriaLabel } : {}),
+        ...(valueSuffix ? { valueSuffix } : {}),
+        ...(typeof value.compactValue === 'boolean' ? { compactValue: value.compactValue } : {}),
+        ...(Object.prototype.hasOwnProperty.call(value, 'value') ? { value: value.value } : {}),
+        ...(normalizeExpression(value.valueExpr, 'valueExpr') ?? {}),
+        ...(normalizeExpression(value.valueSuffixExpr, 'valueSuffixExpr') ?? {}),
+        ...(normalizeNumber(value.total, 'total') ?? {}),
+        ...(normalizeExpression(value.totalExpr, 'totalExpr') ?? {}),
+        ...(normalizeNumber(value.target, 'target') ?? {}),
+        ...(normalizeExpression(value.targetExpr, 'targetExpr') ?? {}),
+        ...(normalizeNumber(value.baseline, 'baseline') ?? {}),
+        ...(normalizeExpression(value.baselineExpr, 'baselineExpr') ?? {}),
+        ...(normalizePoints(value.points) ?? {}),
+        ...(normalizeExpression(value.pointsExpr, 'pointsExpr') ?? {}),
+        ...(normalizeSegments(value.segments) ?? {}),
+        ...(normalizeExpression(value.segmentsExpr, 'segmentsExpr') ?? {}),
+        ...(normalizeThresholds(value.thresholds) ?? {}),
+        ...(normalizeExpression(value.thresholdsExpr, 'thresholdsExpr') ?? {}),
+        ...(normalizeItems(value.items) ?? {}),
+        ...(normalizeExpression(value.itemsExpr, 'itemsExpr') ?? {}),
+        ...(normalizeExpression(value.toneExpr, 'toneExpr') ?? {}),
+        ...(value.stepLabelWidth !== undefined && (typeof value.stepLabelWidth === 'number' || typeof value.stepLabelWidth === 'string')
+            ? { stepLabelWidth: value.stepLabelWidth }
+            : {}),
+        ...(typeof value.stepLabelLineClamp === 'number' && Number.isFinite(value.stepLabelLineClamp)
+            ? { stepLabelLineClamp: value.stepLabelLineClamp }
+            : {}),
+        ...(normalizeExpression(value.ariaLabelExpr, 'ariaLabelExpr') ?? {}),
+        ...(normalizeExpression(value.fallbackTextExpr, 'fallbackTextExpr') ?? {}),
+    };
+}
+function isPraxisPresentationVisualizationTableSafe(value) {
+    const normalized = normalizePraxisPresentationVisualization(value);
+    return !!normalized && TABLE_SAFE_KINDS.has(normalized.kind);
+}
+function renderPraxisPresentationVisualizationHtml(value, options = {}) {
+    const visualization = normalizePraxisPresentationVisualization(value);
+    if (!visualization) {
+        return '';
+    }
+    switch (visualization.kind) {
+        case 'comparison':
+            return renderComparisonVisualizationHtml(visualization, options);
+        case 'stackedBar':
+            return renderStackedBarVisualizationHtml(visualization, options);
+        case 'bullet':
+            return renderBulletVisualizationHtml(visualization, options);
+        case 'delta':
+            return renderDeltaVisualizationHtml(visualization, options);
+        case 'radial':
+            return renderRadialVisualizationHtml(visualization, options);
+        case 'harveyBall':
+            return renderHarveyBallVisualizationHtml(visualization, options);
+        case 'line':
+            return renderLineVisualizationHtml(visualization, options);
+        case 'area':
+            return renderAreaVisualizationHtml(visualization, options);
+        case 'column':
+            return renderColumnVisualizationHtml(visualization, options);
+        case 'processFlow':
+            return renderProcessFlowVisualizationHtml(visualization, options);
+        default:
+            return `<span class="pfx-micro-viz__fallback">${escapeHtml(visualization.fallbackText)}</span>`;
+    }
+}
+function renderComparisonVisualizationHtml(visualization, options) {
+    const points = visualization.points ?? [];
+    if (points.length === 0) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const max = Math.max(1, ...points.map((point) => Math.max(0, point.value)));
+    const rows = points
+        .map((point) => {
+        const width = percent(point.value, max);
+        return `
+        <span class="pfx-micro-viz__row" data-tone="${escapeHtml(point.tone ?? visualization.tone ?? 'info')}">
+          <span class="pfx-micro-viz__label">${escapeHtml(point.label ?? '')}</span>
+          <span class="pfx-micro-viz__track">
+            <span class="pfx-micro-viz__bar" style="width:${width}%"></span>
+          </span>
+          <span class="pfx-micro-viz__value">${escapeHtml(formatMicroNumber(point.value, options.locale))}</span>
+        </span>`;
+    })
+        .join('');
+    return `<span class="pfx-micro-viz" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">${rows}</span>`;
+}
+function renderStackedBarVisualizationHtml(visualization, options) {
+    const segments = visualization.segments ?? [];
+    if (segments.length === 0) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const total = visualization.total && visualization.total > 0
+        ? visualization.total
+        : Math.max(1, segments.reduce((sum, segment) => sum + Math.max(0, segment.value), 0));
+    const bars = segments
+        .map((segment) => `
+      <span
+        class="pfx-micro-viz__segment"
+        data-tone="${escapeHtml(segment.tone ?? visualization.tone ?? 'info')}"
+        style="width:${percent(segment.value, total)}%"
+        title="${escapeHtml(`${segment.label ?? ''} ${formatMicroNumber(segment.value, options.locale)}`.trim())}"
+      ></span>`)
+        .join('');
+    const meta = segments
+        .slice(0, 3)
+        .map((segment) => `<span>${escapeHtml(segment.label ?? '')}: ${escapeHtml(formatMicroNumber(segment.value, options.locale))}</span>`)
+        .join('');
+    return `
+    <span class="pfx-micro-viz" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">
+      <span class="pfx-micro-viz__segments">${bars}</span>
+      <span class="pfx-micro-viz__meta">${meta}</span>
+    </span>`;
+}
+function resolveBulletMax(visualization) {
+    const thresholds = visualization.thresholds ?? [];
+    const thresholdValues = thresholds
+        .map(t => t.value ?? t.max ?? t.min ?? 0)
+        .filter((v) => Number.isFinite(v) && v > 0);
+    const values = [
+        toFiniteNumber(visualization.value) ?? 0,
+        visualization.target ?? 0,
+        visualization.total ?? 0,
+        ...thresholdValues
+    ].filter((v) => Number.isFinite(v) && v > 0);
+    return Math.max(...values, 100);
+}
+function renderBulletVisualizationHtml(visualization, options) {
+    const currentValue = toFiniteNumber(visualization.value);
+    if (currentValue === undefined) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const max = resolveBulletMax(visualization);
+    const target = toFiniteNumber(visualization.target);
+    const targetLeft = target === undefined ? null : percent(target, max);
+    const isTable = visualization.surface === 'table-cell';
+    // thresholds: sort ascending by boundary value so bands draw continuously regardless of declaration order
+    const thresholds = visualization.thresholds ?? [];
+    const sortedThresholds = [...thresholds].sort((a, b) => {
+        const aVal = a.value ?? a.max ?? a.min ?? 0;
+        const bVal = b.value ?? b.max ?? b.min ?? 0;
+        return aVal - bVal;
+    });
+    let previous = 0;
+    const bands = sortedThresholds.map(t => {
+        const tVal = t.value ?? t.max ?? t.min ?? 0;
+        const current = Math.max(tVal, previous);
+        const left = max > 0 ? percent(previous, max) : '0';
+        const width = max > 0 ? percent(current - previous, max) : '0';
+        previous = current;
+        return { left, width, tone: t.tone ?? 'info' };
+    }).filter(b => parseFloat(b.width) > 0);
+    const bandsHtml = bands.map(b => `<span class="pfx-micro-bullet__range" data-tone="${escapeHtml(b.tone)}" style="left: ${b.left}%; width: ${b.width}%;"></span>`).join('');
+    const topHtml = isTable ? '' : `
+    <div class="pfx-micro-bullet__top">
+      <span class="pfx-micro-bullet__label">${escapeHtml(visualization.fallbackText)}</span>
+      <span class="pfx-micro-bullet__value">
+        ${escapeHtml(formatMicroNumber(currentValue, options.locale))}
+        ${target === undefined ? '' : `<span class="pfx-micro-bullet__target-val">/ Target: ${escapeHtml(formatMicroNumber(target, options.locale))}</span>`}
+      </span>
+    </div>`;
+    const bottomHtml = isTable ? '' : `
+    <div class="pfx-micro-bullet__bottom">
+      <span>${escapeHtml(formatMicroNumber(visualization.baseline ?? 0, options.locale))}</span>
+      <span>${escapeHtml(formatMicroNumber(max, options.locale))}</span>
+    </div>`;
+    const showCompactValue = isTable && visualization.compactValue !== false;
+    const compactValueHtml = showCompactValue
+        ? `<span class="pfx-micro-bullet__compact-value">${escapeHtml(formatMicroNumber(currentValue, options.locale))}${escapeHtml(visualization.valueSuffix ?? '')}</span>`
+        : '';
+    return `
+    <span class="pfx-micro-viz pfx-micro-viz__bullet" data-tone="${escapeHtml(visualization.tone ?? 'info')}" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">
+      ${topHtml}
+      <span class="pfx-micro-bullet__track">
+        ${bandsHtml}
+        <span class="pfx-micro-bullet__actual" data-tone="${escapeHtml(visualization.tone ?? 'info')}" style="width: ${percent(currentValue, max)}%;"></span>
+        ${targetLeft === null ? '' : `<span class="pfx-micro-bullet__target" style="left: ${targetLeft}%;"></span>`}
+      </span>
+      ${bottomHtml}
+      ${compactValueHtml}
+    </span>`;
+}
+function renderDeltaVisualizationHtml(visualization, options) {
+    const value = toFiniteNumber(visualization.value);
+    const direction = value === undefined ? 'neutral' : value < 0 ? 'down' : value > 0 ? 'up' : 'neutral';
+    const symbol = direction === 'up' ? '&#9650;' : direction === 'down' ? '&#9660;' : '&rarr;';
+    const tone = visualization.tone ??
+        (value === undefined
+            ? 'neutral'
+            : value < 0
+                ? 'danger'
+                : value > 0
+                    ? 'success'
+                    : 'neutral');
+    const valueSuffix = visualization.valueSuffix ?? '';
+    const text = value === undefined
+        ? visualization.fallbackText
+        : `${formatMicroNumber(Math.abs(value), options.locale)}${valueSuffix}`;
+    const directionLabel = direction === 'up'
+        ? 'up'
+        : direction === 'down'
+            ? 'down'
+            : 'stable';
+    const aria = visualization.ariaLabel ?? `${visualization.fallbackText}: ${directionLabel} ${text}`;
+    return `
+    <span class="pfx-micro-viz pfx-micro-viz__delta" data-tone="${escapeHtml(tone)}" data-direction="${escapeHtml(direction)}" role="img" aria-label="${escapeHtml(aria)}">
+      <span class="pfx-micro-viz__delta-symbol" aria-hidden="true">${symbol}</span>
+      <span>${escapeHtml(text)}</span>
+    </span>`;
+}
+function percent(value, total) {
+    if (!Number.isFinite(value) || !Number.isFinite(total) || total <= 0) {
+        return '0';
+    }
+    return Math.max(0, Math.min(100, (value / total) * 100)).toFixed(2);
+}
+function toFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function formatMicroNumber(value, locale) {
+    return new Intl.NumberFormat(locale || undefined, {
+        maximumFractionDigits: Math.abs(value) < 10 ? 2 : 0,
+    }).format(value);
+}
+function escapeHtml(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function normalizePoints(value) {
+    const points = normalizeNumericEntries(value);
+    return points.length ? { points } : undefined;
+}
+function normalizeSegments(value) {
+    const segments = normalizeNumericEntries(value);
+    return segments.length ? { segments } : undefined;
+}
+function normalizeThresholds(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const thresholds = value
+        .map((item) => {
+        if (!item || typeof item !== 'object')
+            return undefined;
+        const numVal = toFiniteNumber(item.value);
+        const minVal = toFiniteNumber(item.min);
+        const maxVal = toFiniteNumber(item.max);
+        const tone = normalizeEnum$1(item.tone, VISUALIZATION_TONES);
+        const label = normalizeText$1(item.label);
+        const hasCondition = numVal !== undefined || minVal !== undefined || maxVal !== undefined || item.equals !== undefined;
+        if (!hasCondition) {
+            return undefined;
+        }
+        return {
+            ...(label ? { label } : {}),
+            ...(numVal !== undefined ? { value: numVal } : {}),
+            ...(minVal !== undefined ? { min: minVal } : {}),
+            ...(maxVal !== undefined ? { max: maxVal } : {}),
+            ...(item.equals !== undefined ? { equals: item.equals } : {}),
+            ...(tone ? { tone } : {}),
+        };
+    })
+        .filter((item) => !!item);
+    return thresholds.length ? { thresholds } : undefined;
+}
+function normalizeItems(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .map((item) => normalizeVisualizationItem(item))
+        .filter((item) => !!item);
+    return items.length ? { items } : undefined;
+}
+function normalizeExpression(value, key) {
+    if (typeof value === 'string') {
+        const normalized = value.trim();
+        return normalized ? { [key]: normalized } : undefined;
+    }
+    if (value && typeof value === 'object') {
+        return { [key]: value };
+    }
+    return undefined;
+}
+function normalizeNumericEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => {
+        if (!item || typeof item !== 'object' || !Number.isFinite(item.value)) {
+            return null;
+        }
+        const label = normalizeText$1(item.label);
+        const tone = normalizeEnum$1(item.tone, VISUALIZATION_TONES);
+        return {
+            value: item.value,
+            ...(label ? { label } : {}),
+            ...(tone ? { tone } : {}),
+        };
+    })
+        .filter((item) => !!item);
+}
+function normalizeVisualizationItem(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
+    const id = normalizeText$1(item.id);
+    const label = normalizeText$1(item.label);
+    const icon = normalizeText$1(item.icon);
+    const state = normalizeText$1(item.state);
+    const tone = normalizeEnum$1(item.tone, VISUALIZATION_TONES);
+    const normalizedValue = Number.isFinite(item.value) ? item.value : undefined;
+    if (!id && !label && normalizedValue === undefined && !icon && !state && !tone) {
+        return null;
+    }
+    return {
+        ...(id ? { id } : {}),
+        ...(label ? { label } : {}),
+        ...(normalizedValue !== undefined ? { value: normalizedValue } : {}),
+        ...(icon ? { icon } : {}),
+        ...(state ? { state } : {}),
+        ...(tone ? { tone } : {}),
+    };
+}
+function normalizeNumber(value, key) {
+    return Number.isFinite(value) ? { [key]: value } : undefined;
+}
+function normalizeEnum$1(value, allowed) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return allowed.has(normalized) ? normalized : undefined;
+}
+function normalizeText$1(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function renderRadialVisualizationHtml(visualization, options) {
+    const value = toFiniteNumber(visualization.value);
+    if (value === undefined) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const total = visualization.total && visualization.total > 0 ? visualization.total : 100;
+    const pct = Math.max(0, Math.min(100, (value / total) * 100));
+    const tone = visualization.tone ?? 'info';
+    const dashArray = `${pct.toFixed(1)}, 100`;
+    const pctText = `${Math.round(pct)}%`;
+    const aria = visualization.ariaLabel ?? `${visualization.fallbackText} (${pctText})`;
+    const isTable = visualization.surface === 'table-cell';
+    const svgText = isTable
+        ? ''
+        : `<text x="18" y="21" class="pfx-micro-radial-svg__text">${escapeHtml(pctText)}</text>`;
+    const externalText = isTable
+        ? `<span class="pfx-micro-radial-value">${escapeHtml(pctText)}</span>`
+        : '';
+    return `
+    <span class="pfx-micro-viz pfx-micro-viz__radial" data-tone="${escapeHtml(tone)}" role="img" aria-label="${escapeHtml(aria)}">
+      <svg class="pfx-micro-radial-svg" viewBox="0 0 36 36">
+        <circle class="pfx-micro-radial-svg__track" cx="18" cy="18" r="15.9155" />
+        <circle class="pfx-micro-radial-svg__bar" cx="18" cy="18" r="15.9155" stroke-dasharray="${dashArray}" transform="rotate(-90 18 18)" />
+        ${svgText}
+      </svg>
+      ${externalText}
+    </span>`;
+}
+function renderHarveyBallVisualizationHtml(visualization, options) {
+    const value = toFiniteNumber(visualization.value);
+    if (value === undefined) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const total = visualization.total && visualization.total > 0 ? visualization.total : 100;
+    const pct = Math.max(0, Math.min(100, (value / total) * 100));
+    const tone = visualization.tone ?? 'info';
+    const strokeLength = pct * 0.50265;
+    const dashArray = `${strokeLength.toFixed(3)} 50.265`;
+    const aria = visualization.ariaLabel ?? `${visualization.fallbackText} (${Math.round(pct)}%)`;
+    return `
+    <span class="pfx-micro-viz pfx-micro-viz__harvey" data-tone="${escapeHtml(tone)}" role="img" aria-label="${escapeHtml(aria)}">
+      <svg class="pfx-micro-harvey-svg" viewBox="0 0 36 36">
+        <circle class="pfx-micro-harvey-svg__track" cx="18" cy="18" r="16" />
+        <circle class="pfx-micro-harvey-svg__bar" cx="18" cy="18" r="8" stroke-dasharray="${dashArray}" transform="rotate(-90 18 18)" />
+      </svg>
+      <span class="pfx-micro-harvey-fraction">
+        <strong>${escapeHtml(formatMicroNumber(value, options.locale))}</strong>
+        <span class="pfx-separator">/</span>
+        <span class="pfx-total">${escapeHtml(formatMicroNumber(total, options.locale))}</span>
+      </span>
+    </span>`;
+}
+function getPointsCoordinates(points, width, height, padding) {
+    if (points.length < 2)
+        return [];
+    const values = points.map(p => p.value);
+    const minVal = Math.min(...values);
+    const maxVal = Math.max(...values);
+    const valRange = maxVal - minVal === 0 ? 1 : maxVal - minVal;
+    return points.map((p, index) => {
+        const x = padding + (index / (points.length - 1)) * (width - 2 * padding);
+        const y = height - padding - ((p.value - minVal) / valRange) * (height - 2 * padding);
+        return { x, y };
+    });
+}
+function renderLineVisualizationHtml(visualization, options) {
+    const points = visualization.points ?? [];
+    const tone = visualization.tone ?? 'info';
+    if (points.length < 2) {
+        return renderFallbackVisualizationHtml(visualization, tone);
+    }
+    const width = 100;
+    const height = 30;
+    const padding = 4;
+    const coords = getPointsCoordinates(points, width, height, padding);
+    const pathD = coords.map((c, i) => `${i === 0 ? 'M' : 'L'} ${c.x.toFixed(1)} ${c.y.toFixed(1)}`).join(' ');
+    // Highlight extreme/boundary values
+    let minIdx = 0;
+    let maxIdx = 0;
+    for (let i = 1; i < points.length; i++) {
+        if (points[i].value < points[minIdx].value)
+            minIdx = i;
+        if (points[i].value > points[maxIdx].value)
+            maxIdx = i;
+    }
+    const markers = [
+        { x: coords[0].x, y: coords[0].y, tone: points[0].tone ?? tone },
+        { x: coords[coords.length - 1].x, y: coords[coords.length - 1].y, tone: points[points.length - 1].tone ?? tone }
+    ];
+    if (minIdx !== 0 && minIdx !== coords.length - 1) {
+        markers.push({ x: coords[minIdx].x, y: coords[minIdx].y, tone: points[minIdx].tone ?? 'danger' });
+    }
+    if (maxIdx !== 0 && maxIdx !== coords.length - 1) {
+        markers.push({ x: coords[maxIdx].x, y: coords[maxIdx].y, tone: points[maxIdx].tone ?? 'success' });
+    }
+    const circlesHtml = markers.map(c => `<circle cx="${c.x.toFixed(1)}" cy="${c.y.toFixed(1)}" r="2.5" class="pfx-micro-trend__marker" data-tone="${escapeHtml(c.tone)}" />`).join('');
+    const isTable = visualization.surface === 'table-cell';
+    const firstPoint = points[0];
+    const lastPoint = points[points.length - 1];
+    const leftHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--start">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(firstPoint.value, options.locale))}</span>
+      ${firstPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(firstPoint.label)}</span>` : ''}
+    </div>`;
+    const rightHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--end">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(lastPoint.value, options.locale))}</span>
+      ${lastPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(lastPoint.label)}</span>` : ''}
+    </div>`;
+    return `
+    <span class="pfx-micro-viz-container">
+      ${leftHtml}
+      <span class="pfx-micro-viz pfx-micro-viz__line" data-tone="${escapeHtml(tone)}" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">
+        <svg class="pfx-micro-line__svg" viewBox="0 0 100 30">
+          <path class="pfx-micro-line__path" d="${pathD}" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+          ${circlesHtml}
+        </svg>
+      </span>
+      ${rightHtml}
+    </span>`;
+}
+function renderAreaVisualizationHtml(visualization, options) {
+    const points = visualization.points ?? [];
+    const tone = visualization.tone ?? 'info';
+    if (points.length < 2) {
+        return renderFallbackVisualizationHtml(visualization, tone);
+    }
+    const width = 100;
+    const height = 30;
+    const padding = 4;
+    const coords = getPointsCoordinates(points, width, height, padding);
+    const lineD = coords.map((c, i) => `${i === 0 ? 'M' : 'L'} ${c.x.toFixed(1)} ${c.y.toFixed(1)}`).join(' ');
+    const firstX = coords[0].x.toFixed(1);
+    const lastX = coords[coords.length - 1].x.toFixed(1);
+    const areaD = `${lineD} L ${lastX} ${height} L ${firstX} ${height} Z`;
+    // Highlight extreme/boundary values
+    let minIdx = 0;
+    let maxIdx = 0;
+    for (let i = 1; i < points.length; i++) {
+        if (points[i].value < points[minIdx].value)
+            minIdx = i;
+        if (points[i].value > points[maxIdx].value)
+            maxIdx = i;
+    }
+    const markers = [
+        { x: coords[0].x, y: coords[0].y, tone: points[0].tone ?? tone },
+        { x: coords[coords.length - 1].x, y: coords[coords.length - 1].y, tone: points[points.length - 1].tone ?? tone }
+    ];
+    if (minIdx !== 0 && minIdx !== coords.length - 1) {
+        markers.push({ x: coords[minIdx].x, y: coords[minIdx].y, tone: points[minIdx].tone ?? 'danger' });
+    }
+    if (maxIdx !== 0 && maxIdx !== coords.length - 1) {
+        markers.push({ x: coords[maxIdx].x, y: coords[maxIdx].y, tone: points[maxIdx].tone ?? 'success' });
+    }
+    const circlesHtml = markers.map(c => `<circle cx="${c.x.toFixed(1)}" cy="${c.y.toFixed(1)}" r="2.5" class="pfx-micro-trend__marker" data-tone="${escapeHtml(c.tone)}" />`).join('');
+    const isTable = visualization.surface === 'table-cell';
+    const firstPoint = points[0];
+    const lastPoint = points[points.length - 1];
+    const leftHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--start">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(firstPoint.value, options.locale))}</span>
+      ${firstPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(firstPoint.label)}</span>` : ''}
+    </div>`;
+    const rightHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--end">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(lastPoint.value, options.locale))}</span>
+      ${lastPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(lastPoint.label)}</span>` : ''}
+    </div>`;
+    return `
+    <span class="pfx-micro-viz-container">
+      ${leftHtml}
+      <span class="pfx-micro-viz pfx-micro-viz__area" data-tone="${escapeHtml(tone)}" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">
+        <svg class="pfx-micro-area__svg" viewBox="0 0 100 30">
+          <path class="pfx-micro-area__fill" d="${areaD}" fill="currentColor" fill-opacity="0.15" />
+          <path class="pfx-micro-area__path" d="${lineD}" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+          ${circlesHtml}
+        </svg>
+      </span>
+      ${rightHtml}
+    </span>`;
+}
+function renderColumnVisualizationHtml(visualization, options) {
+    const points = visualization.points ?? [];
+    const tone = visualization.tone ?? 'info';
+    if (points.length === 0) {
+        return renderFallbackVisualizationHtml(visualization, tone);
+    }
+    const width = 100;
+    const height = 30;
+    const padding = 4;
+    const values = points.map(p => p.value);
+    const maxVal = Math.max(...values, 0);
+    const minVal = Math.min(...values, 0);
+    const valRange = maxVal - minVal === 0 ? 1 : maxVal - minVal;
+    const colWidth = Math.max(2, (width - 2 * padding) / points.length - 2);
+    const columnsHtml = points.map((p, i) => {
+        const x = padding + i * ((width - 2 * padding) / points.length) + 1;
+        const rectHeight = Math.max(2, ((p.value - minVal) / valRange) * (height - 2 * padding));
+        const rectY = height - padding - rectHeight;
+        const itemTone = p.tone ??
+            (visualization.thresholds?.length
+                ? resolvePraxisMicroVisualizationTone(p.value, visualization.thresholds)?.tone ?? tone
+                : tone);
+        return `<rect class="pfx-micro-column__bar" x="${x.toFixed(1)}" y="${rectY.toFixed(1)}" width="${colWidth.toFixed(1)}" height="${rectHeight.toFixed(1)}" fill="currentColor" data-tone="${escapeHtml(itemTone)}" />`;
+    }).join('');
+    const isTable = visualization.surface === 'table-cell';
+    const firstPoint = points[0];
+    const lastPoint = points[points.length - 1];
+    const leftHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--start">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(firstPoint.value, options.locale))}</span>
+      ${firstPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(firstPoint.label)}</span>` : ''}
+    </div>`;
+    const rightHtml = isTable ? '' : `
+    <div class="pfx-micro-trend__label-col pfx-micro-trend__label-col--end">
+      <span class="pfx-micro-trend__value">${escapeHtml(formatMicroNumber(lastPoint.value, options.locale))}</span>
+      ${lastPoint.label ? `<span class="pfx-micro-trend__label">${escapeHtml(lastPoint.label)}</span>` : ''}
+    </div>`;
+    return `
+    <span class="pfx-micro-viz-container">
+      ${leftHtml}
+      <span class="pfx-micro-viz pfx-micro-viz__column" data-tone="${escapeHtml(tone)}" role="img" aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}">
+        <svg class="pfx-micro-column__svg" viewBox="0 0 100 30">
+          ${columnsHtml}
+        </svg>
+      </span>
+      ${rightHtml}
+    </span>`;
+}
+function renderProcessFlowVisualizationHtml(visualization, options) {
+    const items = visualization.items ?? [];
+    if (items.length === 0) {
+        return renderFallbackVisualizationHtml(visualization, visualization.tone ?? 'neutral');
+    }
+    const isTable = visualization.surface === 'table-cell';
+    const stepLabels = items.map((item, index) => item.label ?? item.id ?? `${index + 1}`);
+    const aria = visualization.ariaLabel ?? `${visualization.fallbackText}: ${stepLabels.join(' > ')}`;
+    const labelStyleAttr = [];
+    if (visualization.stepLabelWidth !== undefined) {
+        const widthVal = typeof visualization.stepLabelWidth === 'number'
+            ? `${visualization.stepLabelWidth}px`
+            : String(visualization.stepLabelWidth);
+        labelStyleAttr.push(`inline-size: ${escapeHtml(widthVal)}; max-width: ${escapeHtml(widthVal)};`);
+    }
+    if (visualization.stepLabelLineClamp !== undefined) {
+        labelStyleAttr.push(`-webkit-line-clamp: ${visualization.stepLabelLineClamp};`);
+    }
+    const labelInlineStyle = labelStyleAttr.length ? ` style="${labelStyleAttr.join(' ')}"` : '';
+    const stepsHtml = items.map((item, index) => {
+        const itemTone = item.tone ?? 'neutral';
+        const itemState = item.state ?? '';
+        const isLast = index === items.length - 1;
+        const itemLabel = stepLabels[index];
+        const label = !isTable && item.label ? `<span class="pfx-micro-step__label"${labelInlineStyle}>${escapeHtml(item.label)}</span>` : '';
+        const connector = !isLast ? `<span class="pfx-micro-step__connector" data-tone="${escapeHtml(itemTone)}"></span>` : '';
+        const stepCircle = `
+      <span class="pfx-micro-step__node" data-tone="${escapeHtml(itemTone)}" aria-hidden="true">
+        ${item.icon ? `<span class="material-icons pfx-micro-step__icon" aria-hidden="true">${escapeHtml(item.icon)}</span>` : `${index + 1}`}
+      </span>`;
+        return `
+      <div class="pfx-micro-step" data-state="${escapeHtml(itemState)}" data-tone="${escapeHtml(itemTone)}">
+        <div class="pfx-micro-step__node-wrapper" title="${escapeHtml(itemLabel)}">
+          ${stepCircle}
+          ${label}
+        </div>
+        ${connector}
+      </div>`;
+    }).join('');
+    return `
+    <span class="pfx-micro-viz pfx-micro-viz__process" role="img" aria-label="${escapeHtml(aria)}">
+      ${stepsHtml}
+    </span>`;
+}
+function renderFallbackVisualizationHtml(visualization, tone) {
+    return `
+    <span
+      class="pfx-micro-viz pfx-micro-viz__fallback"
+      data-tone="${escapeHtml(tone)}"
+      role="img"
+      aria-label="${escapeHtml(visualization.ariaLabel ?? visualization.fallbackText)}"
+    >${escapeHtml(visualization.fallbackText)}</span>`;
+}
+
+const TONES = new Set([
+    'neutral',
+    'info',
+    'success',
+    'warning',
+    'danger',
+]);
+const APPEARANCES = new Set([
+    'plain',
+    'soft',
+    'outlined',
+    'filled',
+]);
+const PRESENTERS = new Set([
+    'text',
+    'badge',
+    'chip',
+    'status',
+    'iconValue',
+    'progress',
+    'rating',
+    'microVisualization',
+]);
+/**
+ * Resolves readonly field presentation from a base semantic config plus ordered
+ * Json Logic rules. Later matching rules override earlier presentation values.
+ */
+function resolveFieldPresentation(base, rules, context = {}, options = {}) {
+    let resolved = normalizeFieldPresentation(base);
+    let matchedRule = false;
+    if (!Array.isArray(rules) || !options.jsonLogic) {
+        return resolved;
+    }
+    for (const rule of rules) {
+        if (!rule?.when || !matchesPresentationRule(rule, context, options.jsonLogic)) {
+            continue;
+        }
+        const effect = normalizeFieldPresentation(rule.set ?? rule.effect);
+        resolved = {
+            ...resolved,
+            ...effect,
+        };
+        matchedRule = true;
+    }
+    return matchedRule ? { ...resolved, matchedRule } : resolved;
+}
+function normalizeFieldPresentation(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    const presenter = normalizePresenter(value.presenter ?? value.variant);
+    const tone = normalizeTone(value.tone);
+    const appearance = normalizeAppearance(value.appearance);
+    const icon = normalizeText(value.icon);
+    const label = normalizeText(value.label);
+    const badge = normalizeText(value.badge);
+    const tooltip = normalizeText(value.tooltip);
+    const prefix = normalizeText(value.prefix);
+    const suffix = normalizeText(value.suffix);
+    const iconTrue = normalizeText(value.iconTrue);
+    const iconFalse = normalizeText(value.iconFalse);
+    const toneTrue = normalizeTone(value.toneTrue);
+    const toneFalse = normalizeTone(value.toneFalse);
+    const labelTrue = normalizeText(value.labelTrue);
+    const labelFalse = normalizeText(value.labelFalse);
+    const visualization = normalizePraxisPresentationVisualization(value.visualization);
+    return {
+        ...(presenter ? { presenter } : {}),
+        ...(tone ? { tone } : {}),
+        ...(appearance ? { appearance } : {}),
+        ...(icon ? { icon } : {}),
+        ...(label ? { label } : {}),
+        ...(badge ? { badge } : {}),
+        ...(tooltip ? { tooltip } : {}),
+        ...(prefix ? { prefix } : {}),
+        ...(suffix ? { suffix } : {}),
+        ...(iconTrue ? { iconTrue } : {}),
+        ...(iconFalse ? { iconFalse } : {}),
+        ...(toneTrue ? { toneTrue } : {}),
+        ...(toneFalse ? { toneFalse } : {}),
+        ...(labelTrue ? { labelTrue } : {}),
+        ...(labelFalse ? { labelFalse } : {}),
+        ...(value.valuePresentation && typeof value.valuePresentation === 'object'
+            ? { valuePresentation: value.valuePresentation }
+            : {}),
+        ...(visualization ? { visualization } : {}),
+        ...(value.interactions && typeof value.interactions === 'object'
+            ? { interactions: normalizeInteractions(value.interactions) }
+            : {}),
+    };
+}
+function matchesPresentationRule(rule, context, jsonLogic) {
+    try {
+        const result = jsonLogic.evaluate(rule.when, context);
+        return typeof jsonLogic.truthy === 'function'
+            ? jsonLogic.truthy(result)
+            : Boolean(result);
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePresenter(value) {
+    return normalizeEnum(value, PRESENTERS);
+}
+function normalizeTone(value) {
+    return normalizeEnum(value, TONES);
+}
+function normalizeAppearance(value) {
+    return normalizeEnum(value, APPEARANCES);
+}
+function normalizeEnum(value, allowed) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return allowed.has(normalized) ? normalized : undefined;
+}
+function normalizeText(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function normalizeInteractions(value) {
+    return {
+        ...(value.copy === true ? { copy: true } : {}),
+        ...(value.details === true ? { details: true } : {}),
+        ...(value.expand === true ? { expand: true } : {}),
+        ...(value.link === true ? { link: true } : {}),
+    };
+}
+
+const VALUE_PRESENTATION_TYPES = new Set([
+    'string',
+    'number',
+    'currency',
+    'percentage',
+    'date',
+    'datetime',
+    'time',
+    'boolean',
+]);
+const VALUE_PRESENTATION_STYLES = new Set([
+    'default',
+    'short',
+    'medium',
+    'long',
+    'full',
+    'compact',
+]);
+const OPTION_SOURCE_TYPES = new Set([
+    'RESOURCE_ENTITY',
+    'DISTINCT_DIMENSION',
+    'CATEGORICAL_BUCKET',
+    'LIGHT_LOOKUP',
+    'STATIC_CANONICAL',
+]);
+const OPTION_SOURCE_SEARCH_MODES = new Set([
+    'none',
+    'starts-with',
+    'contains',
+    'exact',
+]);
+const OPTION_SOURCE_SELECTED_RELOAD_POLICIES = new Set([
+    'required',
+    'supported',
+    'unsupported-with-waiver',
+    'not-applicable',
+]);
+const OPTION_SOURCE_INVALID_SORT_POLICIES = new Set([
+    'reject',
+    'ignore',
+    'unsupported',
+]);
+const LOOKUP_SEARCH_STRATEGY_KINDS = new Set([
+    'business-code',
+    'descriptive-text',
+    'normalized-document',
+]);
+const LOOKUP_OPEN_DETAIL_MODES = new Set([
+    'samePage',
+    'newTab',
+    'drawer',
+    'modal',
+    'route',
+]);
+const LOOKUP_FILTER_FIELD_TYPES = new Set([
+    'text',
+    'enum',
+    'date',
+    'number',
+    'reference',
+]);
+const LOOKUP_FILTER_OPERATORS = new Set([
+    'contains',
+    'startsWith',
+    'equals',
+    'in',
+    'before',
+    'after',
+    'between',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+]);
+/**
+ * SchemaNormalizationKernel (internal)
+ * -----------------------
+ * Cálculo compartilhado pelo serviço Angular, sem DI ou export público, que converte
+ * um esquema bruto (OpenAPI + x-ui) em uma
+ * lista tipada de FieldDefinition consumida pelo restante do sistema
+ * (mapeadores de metadata, criador de FormGroup, carregador de campos dinâmicos, etc.).
+ *
+ * Entrada esperada
+ * - Objeto JSON no formato OpenAPI/JSON Schema contendo:
+ *   - properties: { [name: string]: { type, title, description, ... , 'x-ui': { ... } } }
+ *   - Em cada propriedade, o objeto 'x-ui' define aspectos de UI/validação.
+ *
+ * Saída (FieldDefinition[])
+ * - Tipagem forte de campos com funções reais (nunca strings) para regras condicionais e validadores customizados.
+ * - Todas as propriedades de validação e comportamento consolidadas no mesmo objeto do campo.
+ *
+ * Segurança e observações
+ * - Este serviço aceita funções em formato string dentro do x-ui (ex.: uniqueValidator, conditionalValidation),
+ *   e as converte via new Function. Isso exige backend confiável e controlado.
+ *   Em ambientes não confiáveis, evite funções como string ou implemente um sandbox/whitelist.
+ * - Valores booleanos/numéricos são normalizados para tipos nativos.
+ * - Arrays de opções são convertidos para pares { key, value } previsíveis.
+ *
+ * Exemplo mínimo de entrada
+ * const schema = {
+ *   properties: {
+ *     email: {
+ *       type: 'string',
+ *       title: 'E-mail',
+ *       'x-ui': { controlType: 'input', type: 'string', required: true, email: true }
+ *     }
+ *   }
+ * };
+ * const fields = normalizer.normalizeSchema(schema);
+ * // fields: [{ name: 'email', label: 'E-mail', type: 'string', controlType: 'input', required: true, email: true }]
+ */
+class SchemaNormalizationKernel {
+    clonePlain(value) {
+        if (value === undefined || value === null) {
+            return value;
+        }
+        if (typeof structuredClone === 'function') {
+            try {
+                return structuredClone(value);
+            }
+            catch {
+                // Fall through to JSON clone for plain schema metadata.
+            }
+        }
+        return JSON.parse(JSON.stringify(value));
+    }
+    resolveSchemaRef(ref, rootSchema) {
+        if (typeof ref !== 'string' || !ref.startsWith('#/')) {
+            return undefined;
+        }
+        const segments = ref
+            .slice(2)
+            .split('/')
+            .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+        let cursor = rootSchema;
+        for (const segment of segments) {
+            if (!cursor || typeof cursor !== 'object') {
+                return undefined;
+            }
+            cursor = cursor[segment];
+        }
+        return cursor && typeof cursor === 'object' ? cursor : undefined;
+    }
+    normalizeObjectSchema(schema, rootSchema) {
+        if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+            return [];
+        }
+        return this.normalizeSchemaWithRoot(schema, rootSchema);
+    }
+    normalizeArrayConfig(ui, prop, rootSchema) {
+        const source = ui.array && typeof ui.array === 'object' && !Array.isArray(ui.array)
+            ? this.clonePlain(ui.array)
+            : {};
+        const arrayConfig = source;
+        arrayConfig.itemType = 'object';
+        arrayConfig.mode = 'cards';
+        arrayConfig.deleteMode = 'removeFromPayload';
+        delete arrayConfig['sortable'];
+        delete arrayConfig['itemStateTracking'];
+        if (arrayConfig.operations) {
+            delete arrayConfig.operations['duplicate'];
+            delete arrayConfig.operations['reorder'];
+        }
+        if (prop?.minItems !== undefined && arrayConfig.minItems === undefined) {
+            arrayConfig.minItems = Number(prop.minItems);
+        }
+        if (prop?.maxItems !== undefined && arrayConfig.maxItems === undefined) {
+            arrayConfig.maxItems = Number(prop.maxItems);
+        }
+        const itemSchemaRef = arrayConfig.itemSchemaRef ?? prop?.items?.$ref;
+        if (itemSchemaRef !== undefined) {
+            arrayConfig.itemSchemaRef = String(itemSchemaRef);
+        }
+        const explicitItemSchema = arrayConfig.itemSchema && typeof arrayConfig.itemSchema === 'object'
+            ? arrayConfig.itemSchema
+            : undefined;
+        if (explicitItemSchema && Array.isArray(explicitItemSchema.fields)) {
+            const inlineFields = this.normalizeInlineItemSchemaFields(explicitItemSchema.fields, rootSchema);
+            if (inlineFields.length) {
+                arrayConfig.itemSchema = {
+                    ...explicitItemSchema,
+                    fields: inlineFields,
+                };
+                return this.finalizeArrayConfig(arrayConfig, ui);
+            }
+        }
+        const resolvedItemSchema = explicitItemSchema ??
+            this.resolveSchemaRef(arrayConfig.itemSchemaRef, rootSchema) ??
+            (prop?.items && typeof prop.items === 'object' ? prop.items : undefined);
+        if (resolvedItemSchema && typeof resolvedItemSchema === 'object') {
+            const fields = this.normalizeObjectSchema(resolvedItemSchema, rootSchema);
+            if (fields.length) {
+                arrayConfig.itemSchema = {
+                    ...(explicitItemSchema ?? resolvedItemSchema),
+                    fields,
+                };
+            }
+        }
+        return this.finalizeArrayConfig(arrayConfig, ui);
+    }
+    finalizeArrayConfig(arrayConfig, ui) {
+        const collectionValidation = arrayConfig.collectionValidation ??
+            (ui.collectionValidation && typeof ui.collectionValidation === 'object'
+                ? this.clonePlain(ui.collectionValidation)
+                : undefined);
+        if (collectionValidation) {
+            arrayConfig.collectionValidation = collectionValidation;
+        }
+        return Object.keys(arrayConfig).length ? arrayConfig : undefined;
+    }
+    normalizeInlineItemSchemaFields(fields, rootSchema) {
+        return fields
+            .map((field) => this.normalizeInlineItemSchemaField(field, rootSchema))
+            .filter((field) => !!field);
+    }
+    normalizeInlineItemSchemaField(field, rootSchema) {
+        if (!field || typeof field !== 'object' || Array.isArray(field)) {
+            return undefined;
+        }
+        if (field.controlType || field.dataType || !field['x-ui']) {
+            return this.clonePlain(field);
+        }
+        const name = typeof field.name === 'string' && field.name.trim() ? field.name : undefined;
+        if (!name) {
+            return undefined;
+        }
+        const { name: _name, ...schema } = field;
+        const normalized = this.normalizeSchemaWithRoot({
+            type: 'object',
+            properties: {
+                [name]: schema,
+            },
+        }, rootSchema);
+        return normalized[0];
+    }
+    /** Convert value to boolean. Accepts boolean, string or number. */
+    parseBoolean(value) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true';
+        }
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        return false;
+    }
+    /** Ensure an array of strings from various inputs. */
+    parseStringArray(value) {
+        if (Array.isArray(value)) {
+            return value.map((v) => String(v));
+        }
+        if (typeof value === 'string') {
+            return [value];
+        }
+        return [];
+    }
+    parseNonBlankStringArray(value) {
+        const normalized = this.parseStringArray(value)
+            .map((v) => String(v).trim())
+            .filter((v) => v.length > 0);
+        return normalized.filter((v, index) => normalized.indexOf(v) === index);
+    }
+    parseStringRecord(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const normalized = Object.entries(value)
+            .reduce((acc, [key, mapValue]) => {
+            const normalizedKey = String(key).trim();
+            const normalizedValue = String(mapValue ?? '').trim();
+            if (normalizedKey && normalizedValue) {
+                acc[normalizedKey] = normalizedValue;
+            }
+            return acc;
+        }, {});
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    parseSelectionPolicy(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const policy = {};
+        if (value.selectablePropertyPath !== undefined) {
+            policy.selectablePropertyPath = String(value.selectablePropertyPath);
+        }
+        if (value.statusPropertyPath !== undefined) {
+            policy.statusPropertyPath = String(value.statusPropertyPath);
+        }
+        if (value.allowedStatuses !== undefined) {
+            policy.allowedStatuses = this.parseStringArray(value.allowedStatuses);
+        }
+        if (value.blockedStatuses !== undefined) {
+            policy.blockedStatuses = this.parseStringArray(value.blockedStatuses);
+        }
+        if (value.allowRetainInvalidExistingValue !== undefined) {
+            policy.allowRetainInvalidExistingValue = this.parseBoolean(value.allowRetainInvalidExistingValue);
+        }
+        if (value.disabledReasonTemplate !== undefined) {
+            policy.disabledReasonTemplate = String(value.disabledReasonTemplate);
+        }
+        if (value.validationMessageTemplate !== undefined) {
+            policy.validationMessageTemplate = String(value.validationMessageTemplate);
+        }
+        return Object.keys(policy).length ? policy : undefined;
+    }
+    parseLookupCapabilities(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const booleanKeys = [
+            'filter',
+            'byIds',
+            'detail',
+            'create',
+            'edit',
+            'navigateToDetail',
+            'multiSelect',
+            'recent',
+            'favorites',
+            'auditSnapshot',
+        ];
+        const capabilities = {};
+        booleanKeys.forEach((key) => {
+            if (value[key] !== undefined) {
+                capabilities[key] = this.parseBoolean(value[key]);
+            }
+        });
+        return Object.keys(capabilities).length ? capabilities : undefined;
+    }
+    parseLookupDetail(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const detail = {};
+        if (value.hrefTemplate !== undefined) {
+            detail.hrefTemplate = String(value.hrefTemplate);
+        }
+        if (value.routeTemplate !== undefined) {
+            detail.routeTemplate = String(value.routeTemplate);
+        }
+        if (value.openDetailMode !== undefined) {
+            const openDetailMode = this.parseLookupOpenDetailMode(value.openDetailMode);
+            if (openDetailMode) {
+                detail.openDetailMode = openDetailMode;
+            }
+        }
+        if (value.kind !== undefined) {
+            detail.kind = String(value.kind);
+        }
+        if (value.surfaceId !== undefined) {
+            detail.surfaceId = String(value.surfaceId);
+        }
+        if (value.presentation !== undefined) {
+            detail.presentation = String(value.presentation);
+        }
+        if (value.preferredWidget !== undefined) {
+            detail.preferredWidget = String(value.preferredWidget);
+        }
+        if (value.mode !== undefined) {
+            detail.mode = String(value.mode);
+        }
+        return Object.keys(detail).length ? detail : undefined;
+    }
+    parseLookupDisplay(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const display = {};
+        const stringKeys = [
+            'preset',
+            'usage',
+            'density',
+            'selectedLayout',
+            'resultLayout',
+            'primaryPropertyPath',
+            'avatarPropertyPath',
+        ];
+        stringKeys.forEach((key) => {
+            if (value[key] !== undefined) {
+                display[key] = String(value[key]);
+            }
+        });
+        if (Array.isArray(value.fields)) {
+            const fields = value.fields
+                .map((field) => this.parseLookupDisplayField(field))
+                .filter((field) => !!field);
+            if (fields.length) {
+                display.fields = fields;
+            }
+        }
+        if (value.secondaryPropertyPaths !== undefined) {
+            display.secondaryPropertyPaths = this.parseStringArray(value.secondaryPropertyPaths);
+        }
+        if (value.badgePropertyPaths !== undefined) {
+            display.badgePropertyPaths = this.parseStringArray(value.badgePropertyPaths);
+        }
+        const booleanKeys = [
+            'showAvatar',
+            'showCode',
+            'showDescription',
+            'showStatus',
+            'showBadges',
+            'showDisabledReason',
+            'showResultCount',
+        ];
+        booleanKeys.forEach((key) => {
+            if (value[key] !== undefined) {
+                display[key] = this.parseBoolean(value[key]);
+            }
+        });
+        if (value.maxVisibleBadges !== undefined && !Number.isNaN(Number(value.maxVisibleBadges))) {
+            display.maxVisibleBadges = Number(value.maxVisibleBadges);
+        }
+        return Object.keys(display).length ? display : undefined;
+    }
+    parseLookupDisplayField(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const field = {};
+        ['key', 'propertyPath', 'label', 'icon', 'presentation', 'tone', 'format'].forEach((key) => {
+            if (value[key] !== undefined && String(value[key]).trim().length) {
+                field[key] = String(value[key]);
+            }
+        });
+        return Object.keys(field).length ? field : undefined;
+    }
+    parseLookupCreate(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const create = {};
+        if (value.hrefTemplate !== undefined) {
+            create.hrefTemplate = String(value.hrefTemplate);
+        }
+        if (value.routeTemplate !== undefined) {
+            create.routeTemplate = String(value.routeTemplate);
+        }
+        if (value.openMode !== undefined) {
+            const openMode = this.parseLookupOpenDetailMode(value.openMode);
+            if (openMode) {
+                create.openMode = openMode;
+            }
+        }
+        return Object.keys(create).length ? create : undefined;
+    }
+    parseLookupFilterOperatorArray(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        const normalized = value.map((item) => String(item ?? '').trim());
+        if (normalized.some((item) => !item || !LOOKUP_FILTER_OPERATORS.has(item))) {
+            return [];
+        }
+        return normalized
+            .filter((item, index) => normalized.indexOf(item) === index)
+            .map((item) => item);
+    }
+    parseLookupSortDirection(value) {
+        const normalized = String(value ?? '').trim().toLowerCase();
+        if (normalized === 'asc' || normalized === 'desc') {
+            return normalized;
+        }
+        return undefined;
+    }
+    parseLookupDialogSize(value) {
+        const normalized = String(value ?? '').trim();
+        if (normalized === 'sm' ||
+            normalized === 'md' ||
+            normalized === 'lg' ||
+            normalized === 'xl' ||
+            normalized === 'full') {
+            return normalized;
+        }
+        return undefined;
+    }
+    parseLookupDialog(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const dialog = {};
+        if (value.enabled !== undefined) {
+            dialog.enabled = this.parseBoolean(value.enabled);
+        }
+        if (value.title !== undefined) {
+            const title = String(value.title).trim();
+            if (title) {
+                dialog.title = title;
+            }
+        }
+        if (value.size !== undefined) {
+            const size = this.parseLookupDialogSize(value.size);
+            if (size) {
+                dialog.size = size;
+            }
+        }
+        if (value.previewPanel !== undefined) {
+            dialog.previewPanel = this.parseBoolean(value.previewPanel);
+        }
+        if (value.allowColumnChooser !== undefined) {
+            dialog.allowColumnChooser = this.parseBoolean(value.allowColumnChooser);
+        }
+        if (value.allowSavedViews !== undefined) {
+            dialog.allowSavedViews = this.parseBoolean(value.allowSavedViews);
+        }
+        if (Array.isArray(value.resultColumns)) {
+            const resultColumns = value.resultColumns
+                .map((item) => this.parseLookupResultColumn(item))
+                .filter((item) => !!item);
+            if (resultColumns.length) {
+                dialog.resultColumns = resultColumns;
+            }
+        }
+        if (value.openActionLabel !== undefined) {
+            const openActionLabel = String(value.openActionLabel).trim();
+            if (openActionLabel) {
+                dialog.openActionLabel = openActionLabel;
+            }
+        }
+        if (value.applyActionLabel !== undefined) {
+            const applyActionLabel = String(value.applyActionLabel).trim();
+            if (applyActionLabel) {
+                dialog.applyActionLabel = applyActionLabel;
+            }
+        }
+        if (value.cancelActionLabel !== undefined) {
+            const cancelActionLabel = String(value.cancelActionLabel).trim();
+            if (cancelActionLabel) {
+                dialog.cancelActionLabel = cancelActionLabel;
+            }
+        }
+        return Object.keys(dialog).length ? dialog : undefined;
+    }
+    parseLookupResultColumn(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const field = String(value.field ?? '').trim();
+        if (!field) {
+            return undefined;
+        }
+        const column = { field };
+        if (value.label !== undefined) {
+            const label = String(value.label).trim();
+            if (label) {
+                column.label = label;
+            }
+        }
+        if (value.kind !== undefined) {
+            const kind = String(value.kind).trim();
+            if (kind === 'code' ||
+                kind === 'label' ||
+                kind === 'description' ||
+                kind === 'status' ||
+                kind === 'disabledReason' ||
+                kind === 'custom') {
+                column.kind = kind;
+            }
+        }
+        if (value.width !== undefined) {
+            const width = String(value.width).trim();
+            if (width) {
+                column.width = width;
+            }
+        }
+        return column;
+    }
+    parseLookupFilterDefinition(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const field = String(value.field ?? '').trim();
+        const type = String(value.type ?? '').trim();
+        if (!field || !LOOKUP_FILTER_FIELD_TYPES.has(type)) {
+            return undefined;
+        }
+        const operators = this.parseLookupFilterOperatorArray(value.operators);
+        if (!operators.length) {
+            return undefined;
+        }
+        const definition = {
+            field,
+            type,
+            operators,
+        };
+        if (value.label !== undefined) {
+            definition.label = String(value.label);
+        }
+        const defaultOperator = String(value.defaultOperator ?? '').trim();
+        if (defaultOperator && operators.includes(defaultOperator)) {
+            definition.defaultOperator = defaultOperator;
+        }
+        if (value.optionsSource !== undefined) {
+            const optionsSource = String(value.optionsSource).trim();
+            if (optionsSource) {
+                definition.optionsSource = optionsSource;
+            }
+        }
+        if (value.required !== undefined) {
+            definition.required = this.parseBoolean(value.required);
+        }
+        if (value.hidden !== undefined) {
+            definition.hidden = this.parseBoolean(value.hidden);
+        }
+        return definition;
+    }
+    parseDefaultFilters(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const normalized = Object.entries(value).reduce((acc, [key, item]) => {
+            const normalizedKey = String(key).trim();
+            if (!normalizedKey) {
+                return acc;
+            }
+            const values = Array.isArray(item)
+                ? item.filter((entry) => entry !== undefined)
+                : item === undefined
+                    ? []
+                    : [item];
+            if (values.length) {
+                acc[normalizedKey] = values;
+            }
+            return acc;
+        }, {});
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    parseLookupFiltering(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const filtering = {};
+        if (value.availableFilters !== undefined) {
+            const availableFilters = Array.isArray(value.availableFilters)
+                ? value.availableFilters
+                    .map((item) => this.parseLookupFilterDefinition(item))
+                    .filter((item) => !!item)
+                : [];
+            if (availableFilters.length) {
+                filtering.availableFilters = availableFilters;
+            }
+        }
+        const defaultFilters = this.parseDefaultFilters(value.defaultFilters);
+        if (defaultFilters) {
+            filtering.defaultFilters = defaultFilters;
+        }
+        if (value.sortOptions !== undefined && Array.isArray(value.sortOptions)) {
+            const sortOptions = value.sortOptions
+                .map((item) => {
+                if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                    return undefined;
+                }
+                const key = String(item.key ?? '').trim();
+                const field = String(item.field ?? '').trim();
+                const direction = this.parseLookupSortDirection(item.direction);
+                if (!key || !field || !direction) {
+                    return undefined;
+                }
+                return {
+                    key,
+                    field,
+                    direction,
+                    ...(item.label !== undefined ? { label: String(item.label) } : {}),
+                };
+            })
+                .filter((item) => !!item);
+            if (sortOptions.length) {
+                filtering.sortOptions = sortOptions;
+            }
+        }
+        if (value.defaultSort !== undefined) {
+            const defaultSort = String(value.defaultSort).trim();
+            if (defaultSort) {
+                filtering.defaultSort = defaultSort;
+            }
+        }
+        if (value.quickFilterFields !== undefined) {
+            const quickFilterFields = this.parseNonBlankStringArray(value.quickFilterFields);
+            if (quickFilterFields.length) {
+                filtering.quickFilterFields = quickFilterFields;
+            }
+        }
+        if (value.searchPlaceholder !== undefined) {
+            const searchPlaceholder = String(value.searchPlaceholder).trim();
+            if (searchPlaceholder) {
+                filtering.searchPlaceholder = searchPlaceholder;
+            }
+        }
+        if (Array.isArray(value.searchStrategies)) {
+            const seenKeys = new Set();
+            const searchStrategies = value.searchStrategies
+                .map((item) => {
+                if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                    return undefined;
+                }
+                const raw = item;
+                const key = String(raw.key ?? '').trim();
+                const kind = String(raw.kind ?? '').trim();
+                const minSearchChars = Number(raw.minSearchChars);
+                const inputFormat = String(raw.inputFormat ?? 'text').trim();
+                if (!key ||
+                    seenKeys.has(key) ||
+                    !LOOKUP_SEARCH_STRATEGY_KINDS.has(kind) ||
+                    !['text', 'digits'].includes(inputFormat) ||
+                    !Number.isInteger(minSearchChars) ||
+                    minSearchChars < 1) {
+                    return undefined;
+                }
+                seenKeys.add(key);
+                return {
+                    key,
+                    kind,
+                    minSearchChars,
+                    ...(inputFormat === 'digits' ? { inputFormat } : {}),
+                };
+            })
+                .filter((item) => !!item);
+            if (searchStrategies.length) {
+                filtering.searchStrategies = searchStrategies;
+            }
+        }
+        return Object.keys(filtering).length ? filtering : undefined;
+    }
+    /** Parse option arrays into `{ key, value }` objects with label preservation. */
+    parseOptions(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((opt) => {
+            if (typeof opt === 'object' && opt !== null) {
+                const k = opt.key ?? opt.value ?? opt.id ?? opt.label ?? '';
+                const display = opt.label ??
+                    opt.text ??
+                    opt.title ??
+                    (opt.key !== undefined && opt.value !== undefined && opt.key !== opt.value
+                        ? opt.value
+                        : undefined);
+                const v = display ?? opt.value ?? opt.key ?? '';
+                const result = {
+                    ...opt,
+                    key: String(k),
+                    value: String(v),
+                };
+                if (display !== undefined && display !== null) {
+                    result.label = String(display);
+                }
+                return result;
+            }
+            return { key: String(opt), value: String(opt) };
+        });
+    }
+    parseOptionSource(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const optionSource = {
+            key: String(value.key ?? '').trim(),
+        };
+        if (!optionSource.key) {
+            return undefined;
+        }
+        if (value.type !== undefined) {
+            const optionSourceType = this.parseOptionSourceType(value.type);
+            if (optionSourceType) {
+                optionSource.type = optionSourceType;
+            }
+        }
+        if (value.resourcePath !== undefined) {
+            optionSource.resourcePath = String(value.resourcePath);
+        }
+        if (value.filterField !== undefined) {
+            optionSource.filterField = String(value.filterField);
+        }
+        if (value.propertyPath !== undefined) {
+            optionSource.propertyPath = String(value.propertyPath);
+        }
+        if (value.labelPropertyPath !== undefined) {
+            optionSource.labelPropertyPath = String(value.labelPropertyPath);
+        }
+        if (value.valuePropertyPath !== undefined) {
+            optionSource.valuePropertyPath = String(value.valuePropertyPath);
+        }
+        if (value.entityKey !== undefined) {
+            optionSource.entityKey = String(value.entityKey);
+        }
+        if (value.codePropertyPath !== undefined) {
+            optionSource.codePropertyPath = String(value.codePropertyPath);
+        }
+        if (value.descriptionPropertyPaths !== undefined) {
+            optionSource.descriptionPropertyPaths = this.parseStringArray(value.descriptionPropertyPaths);
+        }
+        if (value.statusPropertyPath !== undefined) {
+            optionSource.statusPropertyPath = String(value.statusPropertyPath);
+        }
+        if (value.disabledPropertyPath !== undefined) {
+            optionSource.disabledPropertyPath = String(value.disabledPropertyPath);
+        }
+        if (value.disabledReasonPropertyPath !== undefined) {
+            optionSource.disabledReasonPropertyPath = String(value.disabledReasonPropertyPath);
+        }
+        if (value.searchPropertyPaths !== undefined) {
+            optionSource.searchPropertyPaths = this.parseStringArray(value.searchPropertyPaths);
+        }
+        if (value.dependsOn !== undefined) {
+            const dependsOn = this.parseNonBlankStringArray(value.dependsOn);
+            if (dependsOn.length) {
+                optionSource.dependsOn = dependsOn;
+            }
+        }
+        const dependencyFilterMap = this.parseStringRecord(value.dependencyFilterMap);
+        if (dependencyFilterMap) {
+            optionSource.dependencyFilterMap = dependencyFilterMap;
+        }
+        const selectionPolicy = this.parseSelectionPolicy(value.selectionPolicy);
+        if (selectionPolicy) {
+            optionSource.selectionPolicy = selectionPolicy;
+        }
+        const capabilities = this.parseLookupCapabilities(value.capabilities);
+        if (capabilities) {
+            optionSource.capabilities = capabilities;
+        }
+        const detail = this.parseLookupDetail(value.detail);
+        if (detail) {
+            optionSource.detail = detail;
+        }
+        const display = this.parseLookupDisplay(value.display);
+        if (display) {
+            optionSource.display = display;
+        }
+        const create = this.parseLookupCreate(value.create);
+        if (create) {
+            optionSource.create = create;
+        }
+        const filtering = this.parseLookupFiltering(value.filtering);
+        if (filtering) {
+            optionSource.filtering = filtering;
+        }
+        if (value.excludeSelfField !== undefined) {
+            optionSource.excludeSelfField = this.parseBoolean(value.excludeSelfField);
+        }
+        if (value.searchMode !== undefined) {
+            const searchMode = this.parseOptionSourceSearchMode(value.searchMode);
+            if (searchMode) {
+                optionSource.searchMode = searchMode;
+            }
+        }
+        if (value.pageSize !== undefined && !Number.isNaN(Number(value.pageSize))) {
+            optionSource.pageSize = Number(value.pageSize);
+        }
+        if (value.includeIds !== undefined) {
+            optionSource.includeIds = this.parseBoolean(value.includeIds);
+        }
+        if (value.selectedReloadPolicy !== undefined) {
+            const selectedReloadPolicy = this.parseOptionSourceSelectedReloadPolicy(value.selectedReloadPolicy);
+            if (selectedReloadPolicy) {
+                optionSource.selectedReloadPolicy = selectedReloadPolicy;
+            }
+        }
+        if (value.invalidSortPolicy !== undefined) {
+            const invalidSortPolicy = this.parseOptionSourceInvalidSortPolicy(value.invalidSortPolicy);
+            if (invalidSortPolicy) {
+                optionSource.invalidSortPolicy = invalidSortPolicy;
+            }
+        }
+        return optionSource;
+    }
+    parseOptionSourceType(value) {
+        const normalized = String(value ?? '').trim().toUpperCase();
+        return OPTION_SOURCE_TYPES.has(normalized) ? normalized : undefined;
+    }
+    parseOptionSourceSearchMode(value) {
+        const normalized = String(value ?? '').trim();
+        return OPTION_SOURCE_SEARCH_MODES.has(normalized) ? normalized : undefined;
+    }
+    parseOptionSourceSelectedReloadPolicy(value) {
+        const normalized = String(value ?? '').trim();
+        return OPTION_SOURCE_SELECTED_RELOAD_POLICIES.has(normalized) ? normalized : undefined;
+    }
+    parseOptionSourceInvalidSortPolicy(value) {
+        const normalized = String(value ?? '').trim();
+        return OPTION_SOURCE_INVALID_SORT_POLICIES.has(normalized) ? normalized : undefined;
+    }
+    parseLookupOpenDetailMode(value) {
+        const normalized = String(value ?? '').trim();
+        return LOOKUP_OPEN_DETAIL_MODES.has(normalized) ? normalized : undefined;
+    }
+    parseValuePresentation(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const typeToken = String(value.type ?? '').trim();
+        if (!typeToken || !VALUE_PRESENTATION_TYPES.has(typeToken)) {
+            if (typeToken) {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.valuePresentation.type: ${typeToken}`);
+            }
+            return undefined;
+        }
+        const presentation = {
+            type: typeToken,
+        };
+        const styleToken = String(value.style ?? '').trim();
+        if (styleToken) {
+            if (VALUE_PRESENTATION_STYLES.has(styleToken)) {
+                presentation.style = styleToken;
+            }
+            else {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.valuePresentation.style: ${styleToken}`);
+            }
+        }
+        const formatToken = String(value.format ?? '').trim();
+        if (formatToken) {
+            presentation.format = formatToken;
+        }
+        if (value.currency && typeof value.currency === 'object') {
+            presentation.currency = { ...value.currency };
+        }
+        if (value.number && typeof value.number === 'object') {
+            presentation.number = { ...value.number };
+        }
+        return presentation;
+    }
+    /**
+     * Converte string/Function em função real.
+     * Atenção: usa `new Function` para avaliar strings – requer backend confiável.
+     */
+    parseFunction(fn) {
+        if (typeof fn === 'function') {
+            return fn;
+        }
+        if (typeof fn === 'string' && fn.trim()) {
+            try {
+                // eslint-disable-next-line no-new-func
+                return new Function(`return (${fn});`)();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    /** Parse a transform function: (val: any) => any */
+    parseTransformFunction(fn) {
+        const parsed = this.parseFunction(fn);
+        if (!parsed)
+            return undefined;
+        return parsed;
+    }
+    parseConditionalValidationRules(value, fieldName) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!Array.isArray(value)) {
+            console.warn(`[SchemaNormalizer] Ignoring non-array x-ui.conditionalValidation for field "${fieldName}". Expected an array of declarative rules.`);
+            return undefined;
+        }
+        const rules = [];
+        value.forEach((candidate, index) => {
+            if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.conditionalValidation[${index}] for field "${fieldName}". Expected an object rule.`);
+                return;
+            }
+            const condition = this.parseJsonLogicExpression(candidate['condition'], fieldName, `x-ui.conditionalValidation[${index}].condition`);
+            const validatorsSource = candidate['validators'];
+            if (!validatorsSource || typeof validatorsSource !== 'object' || Array.isArray(validatorsSource)) {
+                console.warn(`[SchemaNormalizer] Ignoring x-ui.conditionalValidation[${index}] for field "${fieldName}" because validators is missing or invalid.`);
+                return;
+            }
+            rules.push({
+                condition: condition ?? null,
+                validators: this.parseValidators(validatorsSource),
+            });
+        });
+        return rules.length ? rules : undefined;
+    }
+    /**
+     * Extrai e normaliza propriedades de validação a partir do objeto x-ui.
+     * Suporta: required, min/max, minLength/maxLength, pattern/regex, email, url,
+     * matchField, uniqueValidator (+message), conditionalValidation, requiredChecked,
+     * arquivos (allowedFileTypes, fileTypeMessage, maxFileSize), custom/async validators,
+     * minWords e comportamento (validationTrigger(s), validationDebounce, showInlineErrors, errorPosition).
+     */
+    parseValidators(ui, fieldName = 'unknown') {
+        if (!ui || typeof ui !== 'object') {
+            return {};
+        }
+        const out = {};
+        // Basic validators and messages
+        if (ui.required !== undefined)
+            out.required = this.parseBoolean(ui.required);
+        if (ui.requiredMessage !== undefined)
+            out.requiredMessage = ui.requiredMessage;
+        if (ui.minLength !== undefined)
+            out.minLength = Number(ui.minLength);
+        if (ui.minLengthMessage !== undefined)
+            out.minLengthMessage = ui.minLengthMessage;
+        if (ui.maxLength !== undefined)
+            out.maxLength = Number(ui.maxLength);
+        if (ui.maxLengthMessage !== undefined)
+            out.maxLengthMessage = ui.maxLengthMessage;
+        if (ui.min !== undefined)
+            out.min = Number(ui.min);
+        if (ui.max !== undefined)
+            out.max = Number(ui.max);
+        if (ui.minMessage !== undefined)
+            out.minMessage = ui.minMessage;
+        if (ui.maxMessage !== undefined)
+            out.maxMessage = ui.maxMessage;
+        // Range can define both min and max at once. Accept [min, max] or { min, max }
+        if (ui.range !== undefined) {
+            const r = ui.range;
+            if (Array.isArray(r) && r.length >= 2) {
+                if (out.min === undefined && r[0] != null)
+                    out.min = Number(r[0]);
+                if (out.max === undefined && r[1] != null)
+                    out.max = Number(r[1]);
+            }
+            else if (typeof r === 'object' && r) {
+                if (out.min === undefined && r.min != null)
+                    out.min = Number(r.min);
+                if (out.max === undefined && r.max != null)
+                    out.max = Number(r.max);
+            }
+        }
+        if (ui.rangeMessage !== undefined)
+            out.rangeMessage = ui.rangeMessage;
+        // Pattern / Regex
+        if (ui.pattern !== undefined)
+            out.pattern = String(ui.pattern);
+        if (ui.patternMessage !== undefined)
+            out.patternMessage = ui.patternMessage;
+        // Support alias keys: regex / regexMessage
+        if (ui.regex !== undefined && out.pattern === undefined)
+            out.pattern = String(ui.regex);
+        if (ui.regexMessage !== undefined && out.patternMessage === undefined)
+            out.patternMessage = ui.regexMessage;
+        // Email and URL pattern helpers
+        if (ui.email !== undefined)
+            out.email = this.parseBoolean(ui.email);
+        if (ui.emailMessage !== undefined)
+            out.emailMessage = ui.emailMessage;
+        if (ui.url !== undefined)
+            out.url = this.parseBoolean(ui.url);
+        if (ui.urlMessage !== undefined)
+            out.urlMessage = ui.urlMessage;
+        // Matching and unique validators
+        if (ui.matchField !== undefined)
+            out.matchField = String(ui.matchField);
+        if (ui.matchFieldMessage !== undefined)
+            out.matchFieldMessage = ui.matchFieldMessage;
+        if (ui.uniqueMessage !== undefined)
+            out.uniqueMessage = ui.uniqueMessage;
+        if (ui.uniqueValidator !== undefined) {
+            const uniq = this.parseFunction(ui.uniqueValidator);
+            if (uniq)
+                out.uniqueValidator = uniq;
+        }
+        // Conditional validation rules
+        if (ui.conditionalValidation !== undefined) {
+            const cond = this.parseConditionalValidationRules(ui.conditionalValidation, fieldName);
+            if (cond)
+                out.conditionalValidation = cond;
+        }
+        // Checkbox: required to be checked
+        if (ui.requiredChecked !== undefined)
+            out.requiredChecked = this.parseBoolean(ui.requiredChecked);
+        // File validation
+        if (ui.allowedFileTypes !== undefined)
+            out.allowedFileTypes = this.parseStringArray(ui.allowedFileTypes);
+        if (ui.fileTypeMessage !== undefined)
+            out.fileTypeMessage = ui.fileTypeMessage;
+        if (ui.maxFileSize !== undefined)
+            out.maxFileSize = Number(ui.maxFileSize);
+        // Custom validators (sync/async)
+        if (ui.customValidator !== undefined) {
+            const fn = this.parseFunction(ui.customValidator);
+            if (fn)
+                out.customValidator = fn;
+        }
+        if (ui.asyncValidator !== undefined) {
+            const fn = this.parseFunction(ui.asyncValidator);
+            if (fn)
+                out.asyncValidator = fn;
+        }
+        // Word count
+        if (ui.minWords !== undefined)
+            out.minWords = Number(ui.minWords);
+        // Validation behavior
+        if (ui.validationTrigger !== undefined) {
+            out.validationTriggers = Array.isArray(ui.validationTrigger)
+                ? ui.validationTrigger.map((t) => String(t))
+                : [String(ui.validationTrigger)];
+        }
+        if (ui.validationTriggers !== undefined && out.validationTriggers === undefined) {
+            out.validationTriggers = Array.isArray(ui.validationTriggers)
+                ? ui.validationTriggers.map((t) => String(t))
+                : [String(ui.validationTriggers)];
+        }
+        if (ui.validationDebounce !== undefined)
+            out.validationDebounce = Number(ui.validationDebounce);
+        if (ui.showInlineErrors !== undefined)
+            out.showInlineErrors = this.parseBoolean(ui.showInlineErrors);
+        if (ui.errorPosition !== undefined)
+            out.errorPosition = String(ui.errorPosition);
+        return out;
+    }
+    /** Parse array of button definitions. */
+    parseButtons(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((v) => ({ ...v }));
+    }
+    parseJsonLogicExpression(value, fieldName, sourceKey) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            return JSON.parse(JSON.stringify(value));
+        }
+        console.warn(`[SchemaNormalizer] Ignoring non-Json-Logic ${sourceKey} for field "${fieldName}". Expected object/null, received ${typeof value}.`);
+        return undefined;
+    }
+    resolveNonEmptyStringToken(...values) {
+        for (const value of values) {
+            const text = String(value ?? '').trim();
+            if (text.length) {
+                return text;
+            }
+        }
+        return undefined;
+    }
+    isNumericSchemaType(type) {
+        const token = String(type ?? '').trim().toLowerCase();
+        return ['number', 'integer', 'int', 'float', 'double', 'decimal'].includes(token);
+    }
+    resolveNumericFormatToken(prop, ui, resolvedType) {
+        const typeToken = resolvedType ?? prop?.type;
+        if (!this.isNumericSchemaType(typeToken)) {
+            return undefined;
+        }
+        if (ui?.numberFormat?.percentage === true || ui?.['numberFormat.percentage'] === true) {
+            return 'percent';
+        }
+        return this.resolveNonEmptyStringToken(ui?.numericFormat, ui?.format, ui?.numberFormat?.style, ui?.['numberFormat.style'], prop?.format);
+    }
+    /**
+     * Converte o schema bruto do backend (OpenAPI + x-ui) em FieldDefinition[] tipado.
+     * Regras:
+     * - Ignora propriedades sem x-ui.
+     * - Garante ordenação por 'order' quando presente.
+     * - Funções condicionais/transformações sempre viram funções reais.
+     *
+     * @param schema Objeto OpenAPI/JSON Schema com properties e x-ui por propriedade.
+     * @returns FieldDefinition[] prontos para mapeamento/uso no restante do sistema.
+     */
+    normalizeSchema(schema) {
+        return this.normalizeSchemaWithRoot(schema, schema);
+    }
+    normalizeSchemaWithRoot(schema, rootSchema) {
+        if (!schema || typeof schema !== 'object') {
+            return [];
+        }
+        const properties = schema.properties ?? {};
+        const requiredNames = new Set(Array.isArray(schema.required)
+            ? schema.required.filter((name) => typeof name === 'string')
+            : []);
+        const fields = [];
+        for (const [name, prop] of Object.entries(properties)) {
+            const ui = prop &&
+                typeof prop === 'object' &&
+                !Array.isArray(prop) &&
+                prop['x-ui'] &&
+                typeof prop['x-ui'] === 'object' &&
+                !Array.isArray(prop['x-ui'])
+                ? prop['x-ui']
+                : undefined;
+            // Skip properties without x-ui metadata
+            if (!ui || Object.keys(ui).length === 0) {
+                continue;
+            }
+            const field = { name };
+            // -------------------------------------------------------------------
+            // Basic information
+            // -------------------------------------------------------------------
+            field.label = ui.label ?? prop.title ?? name;
+            field.type = this.resolveFieldType(prop, ui);
+            const numericFormat = this.resolveNumericFormatToken(prop, ui, field.type);
+            if (numericFormat) {
+                field.numericFormat = numericFormat;
+                field.format = numericFormat;
+            }
+            const valuePresentation = this.parseValuePresentation(ui.valuePresentation);
+            if (valuePresentation) {
+                field.valuePresentation = valuePresentation;
+            }
+            const presentation = normalizeFieldPresentation(ui.presentation);
+            if (Object.keys(presentation).length > 0) {
+                field.presentation = presentation;
+            }
+            if (ui.controlType) {
+                field.controlType = ui.controlType;
+            }
+            if (field.controlType === 'array' || ui.array !== undefined) {
+                const arrayConfig = this.normalizeArrayConfig(ui, prop, rootSchema);
+                if (arrayConfig) {
+                    field.array = arrayConfig;
+                    if (arrayConfig.collectionValidation) {
+                        field.collectionValidation = arrayConfig.collectionValidation;
+                    }
+                }
+            }
+            if (ui.placeholder !== undefined) {
+                field.placeholder = String(ui.placeholder);
+            }
+            if (ui.mode !== undefined) {
+                field.mode = ui.mode;
+            }
+            if (ui.description || prop.description) {
+                field.description = ui.description ?? prop.description;
+            }
+            if (ui.order !== undefined) {
+                field.order = Number(ui.order);
+            }
+            if (ui.group !== undefined) {
+                field.group = ui.group;
+            }
+            if (ui.selectionMode !== undefined) {
+                field.selectionMode = String(ui.selectionMode);
+            }
+            if (ui.variant !== undefined) {
+                field.variant = String(ui.variant);
+            }
+            if (ui.density !== undefined) {
+                field.density = String(ui.density);
+            }
+            if (ui.layout !== undefined) {
+                field.layout = String(ui.layout);
+            }
+            if (ui.isFlex !== undefined) {
+                field.isFlex = this.parseBoolean(ui.isFlex);
+            }
+            if (ui.displayOrientation !== undefined) {
+                field.displayOrientation = String(ui.displayOrientation);
+            }
+            // -------------------------------------------------------------------
+            // Behaviour and validation
+            // -------------------------------------------------------------------
+            if (ui.readOnly !== undefined) {
+                field.readOnly = this.parseBoolean(ui.readOnly);
+            }
+            if (ui.disabled !== undefined) {
+                field.disabled = this.parseBoolean(ui.disabled);
+            }
+            if (ui.editable !== undefined) {
+                field.editable = this.parseBoolean(ui.editable);
+            }
+            const fieldAccess = normalizeFieldAccessMetadata(ui.fieldAccess);
+            if (fieldAccess) {
+                field.fieldAccess = fieldAccess;
+            }
+            if (ui.inlineEditing !== undefined) {
+                field.inlineEditing = this.parseBoolean(ui.inlineEditing);
+            }
+            if (ui.defaultValue !== undefined) {
+                field.defaultValue = ui.defaultValue;
+            }
+            if (ui.validationMode !== undefined) {
+                field.validationMode = String(ui.validationMode);
+            }
+            if (ui.unique !== undefined) {
+                field.unique = this.parseBoolean(ui.unique);
+            }
+            if (ui.mask !== undefined) {
+                field.mask = String(ui.mask);
+            }
+            if (ui.sortable !== undefined) {
+                field.sortable = this.parseBoolean(ui.sortable);
+            }
+            if (ui.viewOnlyStyle !== undefined) {
+                field.viewOnlyStyle = String(ui.viewOnlyStyle);
+            }
+            Object.assign(field, this.parseValidators(ui, name));
+            // Required membership belongs to the canonical object schema. UI hints
+            // can add validation but cannot make a required request field optional.
+            if (requiredNames.has(name)) {
+                field.required = true;
+            }
+            const condDisplay = this.parseJsonLogicExpression(ui.conditionalDisplay, name, 'x-ui.conditionalDisplay');
+            if (condDisplay !== undefined) {
+                field.conditionalDisplay = condDisplay;
+            }
+            const condRequired = this.parseJsonLogicExpression(ui.conditionalRequired, name, 'x-ui.conditionalRequired');
+            if (condRequired !== undefined) {
+                field.conditionalRequired = condRequired;
+            }
+            const transformFn = this.parseTransformFunction(ui.transformValueFunction);
+            if (transformFn) {
+                field.transformValueFunction = transformFn;
+            }
+            // -------------------------------------------------------------------
+            // Layout and presentation
+            // -------------------------------------------------------------------
+            // Visibility flags (x-ui)
+            if (ui.hidden !== undefined) {
+                field.hidden = this.parseBoolean(ui.hidden);
+            }
+            if (ui.tableHidden !== undefined) {
+                field.tableHidden = this.parseBoolean(ui.tableHidden);
+            }
+            if (ui.formHidden !== undefined) {
+                field.formHidden = this.parseBoolean(ui.formHidden);
+            }
+            if (ui.width !== undefined) {
+                field.width = ui.width;
+            }
+            if (ui.helpText !== undefined) {
+                field.helpText = String(ui.helpText);
+            }
+            if (ui.tooltip !== undefined) {
+                field.tooltip = String(ui.tooltip);
+            }
+            if (ui.hint !== undefined) {
+                field.hint = ui.hint;
+            }
+            if (ui.hiddenCondition !== undefined) {
+                const hiddenCondition = this.parseJsonLogicExpression(ui.hiddenCondition, name, 'x-ui.hiddenCondition');
+                if (hiddenCondition !== undefined) {
+                    field.hiddenCondition = hiddenCondition;
+                }
+            }
+            if (ui.icon !== undefined) {
+                field.icon = ui.icon;
+            }
+            if (ui.iconPosition !== undefined) {
+                field.iconPosition = ui.iconPosition;
+            }
+            if (ui.iconSize !== undefined) {
+                field.iconSize = ui.iconSize;
+            }
+            if (ui.iconColor !== undefined) {
+                field.iconColor = String(ui.iconColor);
+            }
+            if (ui.iconClass !== undefined) {
+                field.iconClass = String(ui.iconClass);
+            }
+            if (ui.iconStyle !== undefined) {
+                field.iconStyle = String(ui.iconStyle);
+            }
+            if (ui.iconFontSize !== undefined) {
+                field.iconFontSize = ui.iconFontSize;
+            }
+            if (ui.tooltipOnHover !== undefined) {
+                field.tooltipOnHover = ui.tooltipOnHover;
+            }
+            if (ui.clearButton !== undefined) {
+                if (typeof ui.clearButton === 'boolean') {
+                    field.clearButton = { enabled: this.parseBoolean(ui.clearButton) };
+                }
+                else if (typeof ui.clearButton === 'object') {
+                    field.clearButton = { ...ui.clearButton };
+                }
+            }
+            if (ui['clearButton.enabled'] !== undefined ||
+                ui['clearButton.icon'] !== undefined ||
+                ui['clearButton.iconColor'] !== undefined ||
+                ui['clearButton.tooltip'] !== undefined ||
+                ui['clearButton.ariaLabel'] !== undefined ||
+                ui['clearButton.showOnlyWhenFilled'] !== undefined) {
+                const clearButton = field.clearButton ?? {};
+                if (ui['clearButton.enabled'] !== undefined) {
+                    clearButton.enabled = this.parseBoolean(ui['clearButton.enabled']);
+                }
+                if (ui['clearButton.icon'] !== undefined) {
+                    clearButton.icon = String(ui['clearButton.icon']);
+                }
+                if (ui['clearButton.iconColor'] !== undefined) {
+                    clearButton.iconColor = String(ui['clearButton.iconColor']);
+                }
+                if (ui['clearButton.tooltip'] !== undefined) {
+                    clearButton.tooltip = String(ui['clearButton.tooltip']);
+                }
+                if (ui['clearButton.ariaLabel'] !== undefined) {
+                    clearButton.ariaLabel = String(ui['clearButton.ariaLabel']);
+                }
+                if (ui['clearButton.showOnlyWhenFilled'] !== undefined) {
+                    clearButton.showOnlyWhenFilled = this.parseBoolean(ui['clearButton.showOnlyWhenFilled']);
+                }
+                field.clearButton = clearButton;
+            }
+            // -------------------------------------------------------------------
+            // Options and dependencies
+            // -------------------------------------------------------------------
+            if (ui.options !== undefined) {
+                field.options = this.parseOptions(ui.options);
+            }
+            if (ui.optionGroups !== undefined) {
+                field.optionGroups = this.parseOptions(ui.optionGroups);
+            }
+            if (ui.disabledOptions !== undefined) {
+                field.disabledOptions = this.parseStringArray(ui.disabledOptions);
+            }
+            if (ui.endpoint !== undefined) {
+                field.endpoint = ui.endpoint;
+            }
+            if (ui.resourcePath !== undefined) {
+                field.resourcePath = ui.resourcePath;
+            }
+            if (ui.optionSource !== undefined) {
+                const optionSource = this.parseOptionSource(ui.optionSource);
+                if (optionSource) {
+                    // Java metadata publishes cascade context beside optionSource. Keep the
+                    // runtime contract canonical by materializing it inside optionSource.
+                    const dependsOn = this.parseNonBlankStringArray(ui.dependsOn);
+                    if (!optionSource.dependsOn?.length && dependsOn.length) {
+                        optionSource.dependsOn = dependsOn;
+                    }
+                    const dependencyFilterMap = this.parseStringRecord(ui.dependencyFilterMap);
+                    if (!optionSource.dependencyFilterMap &&
+                        dependencyFilterMap) {
+                        optionSource.dependencyFilterMap = dependencyFilterMap;
+                    }
+                    field.optionSource = optionSource;
+                }
+            }
+            if (ui.valueField !== undefined) {
+                field.valueField = ui.valueField;
+            }
+            if (ui.displayField !== undefined) {
+                field.displayField = ui.displayField;
+            }
+            if (ui.filterField !== undefined) {
+                field.filterField = ui.filterField;
+            }
+            if (ui.multiple !== undefined) {
+                field.multiple = this.parseBoolean(ui.multiple);
+            }
+            if (ui.filterable !== undefined) {
+                field.filterable = this.parseBoolean(ui.filterable);
+            }
+            if (ui.emptyOptionText !== undefined) {
+                field.emptyOptionText = ui.emptyOptionText;
+            }
+            if (ui.filter !== undefined) {
+                field.filter = ui.filter;
+            }
+            if (ui.dialog !== undefined) {
+                const dialog = this.parseLookupDialog(ui.dialog);
+                if (dialog) {
+                    field.dialog = dialog;
+                }
+            }
+            if (ui.detailActionLabel !== undefined) {
+                const detailActionLabel = String(ui.detailActionLabel).trim();
+                if (detailActionLabel) {
+                    field.detailActionLabel = detailActionLabel;
+                }
+            }
+            if (ui.copyCodeActionLabel !== undefined) {
+                const copyCodeActionLabel = String(ui.copyCodeActionLabel).trim();
+                if (copyCodeActionLabel) {
+                    field.copyCodeActionLabel = copyCodeActionLabel;
+                }
+            }
+            if (ui.copyIdActionLabel !== undefined) {
+                const copyIdActionLabel = String(ui.copyIdActionLabel).trim();
+                if (copyIdActionLabel) {
+                    field.copyIdActionLabel = copyIdActionLabel;
+                }
+            }
+            if (ui.createActionLabel !== undefined) {
+                const createActionLabel = String(ui.createActionLabel).trim();
+                if (createActionLabel) {
+                    field.createActionLabel = createActionLabel;
+                }
+            }
+            if (ui.actions && typeof ui.actions === 'object' && !Array.isArray(ui.actions)) {
+                const actions = {};
+                if (ui.actions.showDetail !== undefined) {
+                    actions.showDetail = this.parseBoolean(ui.actions.showDetail);
+                }
+                if (ui.actions.showCopyCode !== undefined) {
+                    actions.showCopyCode = this.parseBoolean(ui.actions.showCopyCode);
+                }
+                if (ui.actions.showCopyId !== undefined) {
+                    actions.showCopyId = this.parseBoolean(ui.actions.showCopyId);
+                }
+                if (ui.actions.showCreate !== undefined) {
+                    actions.showCreate = this.parseBoolean(ui.actions.showCreate);
+                }
+                if (Object.keys(actions).length) {
+                    field.actions = actions;
+                }
+            }
+            if (ui.filterOptions !== undefined) {
+                field.filterOptions = Array.isArray(ui.filterOptions)
+                    ? [...ui.filterOptions]
+                    : this.parseStringArray(ui.filterOptions);
+            }
+            if (ui.dependentField !== undefined) {
+                field.dependentField = ui.dependentField;
+            }
+            if (ui.resetOnDependentChange !== undefined) {
+                field.resetOnDependentChange = this.parseBoolean(ui.resetOnDependentChange);
+            }
+            if (ui.debounceTime !== undefined) {
+                field.debounceTime = Number(ui.debounceTime);
+            }
+            if (ui.numericStep !== undefined) {
+                field.numericStep = Number(ui.numericStep);
+            }
+            if (ui.numericMin !== undefined) {
+                field.numericMin = Number(ui.numericMin);
+            }
+            if (ui.numericMax !== undefined) {
+                field.numericMax = Number(ui.numericMax);
+            }
+            if (ui.numericMaxLength !== undefined) {
+                field.numericMaxLength = Number(ui.numericMaxLength);
+            }
+            if (ui.buttons !== undefined) {
+                field.buttons = this.parseButtons(ui.buttons);
+            }
+            fields.push(field);
+        }
+        // Order by the optional 'order' property when present
+        fields.sort((a, b) => {
+            const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+            const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+            return orderA - orderB;
+        });
+        return fields;
+    }
+    resolveFieldType(prop, ui) {
+        if (ui?.type !== undefined && ui?.type !== null && String(ui.type).trim() !== '') {
+            return String(ui.type);
+        }
+        if (String(ui?.controlType ?? '').trim() === 'array') {
+            return 'array';
+        }
+        if (prop?.type) {
+            return String(prop.type);
+        }
+        const variants = [
+            ...(Array.isArray(prop?.oneOf) ? prop.oneOf : []),
+            ...(Array.isArray(prop?.anyOf) ? prop.anyOf : []),
+        ].filter((variant) => variant && typeof variant === 'object');
+        const nonNullTypes = Array.from(new Set(variants
+            .map((variant) => (typeof variant.type === 'string' ? variant.type.trim() : ''))
+            .filter((type) => !!type && type !== 'null')));
+        if (nonNullTypes.length === 1) {
+            return nonNullTypes[0];
+        }
+        // Compatibilidade para schemas de range publicados como oneOf(array|object).
+        const controlToken = String(ui?.controlType || '').trim().toLowerCase().replace(/[^a-z0-9]/g, '');
+        const isRangeControl = ['daterange', 'datetimerange', 'rangeslider', 'pricerange'].includes(controlToken);
+        if (isRangeControl && nonNullTypes.includes('array')) {
+            return 'array';
+        }
+        return undefined;
+    }
+}
+
+/** 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.
+ */
+function normalizeSchemaFields(schema) {
+    return new SchemaNormalizationKernel().normalizeSchema(schema);
+}
+
+function isObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * 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
+ */
+function deepMerge(left, right) {
+    if (right === undefined || right === null)
+        return clone(left);
+    if (Array.isArray(left)) {
+        return (Array.isArray(right) ? right : clone(left));
+    }
+    if (!isObject(left) || !isObject(right)) {
+        // Right wins when defined, else left
+        return (right !== undefined ? right : left);
+    }
+    const out = { ...left };
+    for (const key of Object.keys(right)) {
+        const r = right[key];
+        const l = left[key];
+        if (r === undefined)
+            continue; // keep left as-is
+        if (Array.isArray(r)) {
+            out[key] = r.map((v) => clone(v));
+        }
+        else if (isObject(r) && isObject(l)) {
+            out[key] = deepMerge(l, r);
+        }
+        else {
+            out[key] = clone(r);
+        }
+    }
+    return out;
+}
+/**
+ * Fill only undefined properties in `target` with values from `defaults`.
+ * - Objects are traversed recursively
+ * - Arrays defaulting replaces when target is undefined/null
+ */
+function fillUndefined(target, defaults) {
+    if (defaults === undefined || defaults === null)
+        return clone(target);
+    if (!isObject(target) || !isObject(defaults)) {
+        return (target === undefined || target === null ? defaults : target);
+    }
+    const out = { ...target };
+    for (const key of Object.keys(defaults)) {
+        const d = defaults[key];
+        const t = target[key];
+        if (t === undefined || t === null) {
+            out[key] = clone(d);
+        }
+        else if (isObject(t) && isObject(d)) {
+            out[key] = fillUndefined(t, d);
+        }
+        else {
+            out[key] = t;
+        }
+    }
+    return out;
+}
+function clone(v) {
+    if (v == null || typeof v !== 'object')
+        return v;
+    try {
+        return JSON.parse(JSON.stringify(v));
+    }
+    catch {
+        return v;
+    }
+}
+
+function buildBaseColumnFromDef(def) {
+    const type = resolveColumnTypeFromFieldDefinition(def);
+    const format = type === 'string' ? resolveTextMaskFormatFromFieldDefinition(def) : undefined;
+    const renderer = resolveRendererFromFieldPresentation(def);
+    return {
+        field: def.name,
+        header: def.label || def.name,
+        type,
+        visible: def.tableHidden === true ? false : true,
+        sortable: def.sortable !== false,
+        filterable: def.filterable === true,
+        resizable: true,
+        order: typeof def.order === 'number' ? def.order : undefined,
+        ...(format ? { format } : {}),
+        ...(renderer ? { renderer } : {}),
+    };
+}
+function applyLocalCustomizations(baseCol, localCol) {
+    // Server-authoritative keys
+    const result = {
+        ...baseCol,
+        field: baseCol.field,
+        header: baseCol.header, // label comes from server
+        type: baseCol.type, // type comes from server (authoritative)
+        sortable: baseCol.sortable,
+    };
+    // Merge presentation/customization from local, keeping user's preferences
+    // and only cleaning conflicting ones if server type changed.
+    const typeChanged = localCol.type && baseCol.type && localCol.type !== baseCol.type;
+    result.width = localCol.width ?? baseCol.width;
+    result.visible = localCol.visible ?? baseCol.visible;
+    result.filterable = localCol.filterable ?? baseCol.filterable;
+    result.resizable = localCol.resizable ?? baseCol.resizable;
+    result.sticky = localCol.sticky ?? baseCol.sticky;
+    result.align = localCol.align ?? baseCol.align;
+    result.order = localCol.order ?? baseCol.order;
+    result.sortField = localCol.sortField ?? baseCol.sortField;
+    result.style = localCol.style ?? baseCol.style;
+    result.headerStyle = localCol.headerStyle ?? baseCol.headerStyle;
+    result.cssClass = localCol.cssClass ?? baseCol.cssClass;
+    result.headerCssClass = localCol.headerCssClass ?? baseCol.headerCssClass;
+    // If server type changed, drop potentially incompatible formatting/renderers.
+    if (!typeChanged) {
+        result.format = localCol.format ?? baseCol.format;
+        result.valueMapping = localCol.valueMapping ?? baseCol.valueMapping;
+        result.renderer = localCol.renderer ?? baseCol.renderer;
+    }
+    else {
+        // Drop local presentation that may be incompatible with the new server type,
+        // but keep canonical server presentation for the resolved type.
+        result.format = baseCol.format;
+        result.valueMapping = baseCol.valueMapping;
+        result.renderer = undefined;
+    }
+    return result;
+}
+function reconcileTableConfig(layout, serverDefs) {
+    const local = layout || { columns: [] };
+    const localByField = new Map((local.columns || []).map((c) => [c.field, c]));
+    const baseColumns = serverDefs.map(buildBaseColumnFromDef);
+    const mergedColumns = baseColumns.map((base) => {
+        const localCol = localByField.get(base.field);
+        return localCol ? applyLocalCustomizations(base, localCol) : base;
+    });
+    const serverFields = new Set(serverDefs.map((d) => d.name));
+    const orphans = (local.columns || []).filter((c) => !serverFields.has(c.field));
+    const hiddenOrphans = orphans.map((c) => ({ ...c, visible: false }));
+    const next = {
+        ...local,
+        columns: [...mergedColumns, ...hiddenOrphans],
+        meta: {
+            ...local.meta,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+    return next;
+}
+function resolveColumnTypeFromFieldDefinition(def, fallback) {
+    const semanticType = resolveSemanticColumnTypeFromFieldDefinition(def);
+    if (resolveTextMaskFormatFromFieldDefinition(def) &&
+        shouldUseTextMaskForColumn(def, semanticType)) {
+        return 'string';
+    }
+    if (semanticType)
+        return semanticType;
+    if (fallback)
+        return fallback;
+    return 'string';
+}
+function resolveSemanticColumnTypeFromFieldDefinition(def) {
+    const controlType = normalizePresentationToken(def.controlType);
+    const numericFormat = normalizePresentationToken(def.numericFormat ?? def.format);
+    const valuePresentationType = normalizePresentationToken(def.valuePresentation?.type);
+    const dataType = normalizePresentationToken(def.type);
+    if (valuePresentationType === 'currency')
+        return 'currency';
+    if (valuePresentationType === 'percent' || valuePresentationType === 'percentage')
+        return 'percentage';
+    if (valuePresentationType === 'date' || valuePresentationType === 'datetime' || valuePresentationType === 'time')
+        return 'date';
+    if (valuePresentationType === 'boolean')
+        return 'boolean';
+    if (valuePresentationType === 'number')
+        return 'number';
+    if (valuePresentationType === 'string')
+        return 'string';
+    if (numericFormat === 'currency' || controlType === 'currency')
+        return 'currency';
+    if (numericFormat === 'percent' || numericFormat === 'percentage')
+        return 'percentage';
+    if (numericFormat === 'date' || numericFormat === 'datetime')
+        return 'date';
+    if (controlType === 'numerictextbox' || controlType === 'inlinenumber')
+        return 'number';
+    if (controlType === 'checkbox' || controlType === 'toggle' || controlType === 'inlinetoggle')
+        return 'boolean';
+    if (controlType.includes('date') || controlType === 'time' || controlType === 'timepicker')
+        return 'date';
+    if (isColumnType(dataType))
+        return dataType;
+    if (dataType === 'text' || dataType === 'email' || dataType === 'url' || dataType === 'password')
+        return 'string';
+    if (dataType.includes('date') || dataType === 'time')
+        return 'date';
+    if (dataType.includes('bool'))
+        return 'boolean';
+    if (dataType.includes('number') ||
+        dataType.includes('int') ||
+        dataType.includes('decimal') ||
+        dataType.includes('double') ||
+        dataType.includes('float')) {
+        return 'number';
+    }
+    if (isTextualControlType(controlType))
+        return 'string';
+    return undefined;
+}
+function shouldUseTextMaskForColumn(def, semanticType) {
+    if (!semanticType || semanticType === 'string')
+        return true;
+    const controlType = normalizePresentationToken(def.controlType);
+    if (isTextualControlType(controlType))
+        return true;
+    if (['date', 'boolean', 'currency', 'percentage', 'custom'].includes(semanticType)) {
+        return false;
+    }
+    const valuePresentationType = normalizePresentationToken(def.valuePresentation?.type);
+    const numericFormat = normalizePresentationToken(def.numericFormat ?? def.format);
+    return !valuePresentationType && !numericFormat;
+}
+function resolveTextMaskFormatFromFieldDefinition(def) {
+    return resolveTextMaskFormat(def.mask ??
+        def.displayMask ??
+        def.inputMask ??
+        def.extraProperties?.mask);
+}
+function resolveTextMaskFormat(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const format = value.trim();
+    if (!format)
+        return undefined;
+    const hasMaskTokens = /[0#9Xx]/.test(format);
+    const hasInvalidMaskLetters = /[A-WYZa-wyz]/.test(format);
+    return hasMaskTokens && !hasInvalidMaskLetters ? format : undefined;
+}
+function resolveRendererFromFieldPresentation(def) {
+    const presentation = def.presentation;
+    if (!presentation || typeof presentation !== 'object')
+        return undefined;
+    const presenter = normalizePresentationToken(presentation.presenter ?? presentation.variant);
+    const color = resolveSemanticPresentationColor(presentation.tone);
+    const variant = resolveSemanticPresentationVariant(presentation.appearance);
+    const icon = firstNonEmptyString(presentation.icon);
+    const tooltipText = firstNonEmptyString(presentation.tooltip);
+    const tooltip = tooltipText ? { text: tooltipText } : undefined;
+    if (presenter === 'chip') {
+        return {
+            type: 'chip',
+            chip: {
+                textField: def.name,
+                ...(color ? { color } : {}),
+                ...(variant ? { variant } : {}),
+                ...(icon ? { icon } : {}),
+                ...(tooltip ? { tooltip } : {}),
+            },
+        };
+    }
+    if (presenter === 'badge' || presenter === 'status') {
+        return {
+            type: 'badge',
+            badge: {
+                textField: def.name,
+                ...(color ? { color } : {}),
+                ...(variant ? { variant } : {}),
+                ...(icon ? { icon } : {}),
+                ...(tooltip ? { tooltip } : {}),
+            },
+        };
+    }
+    if (presenter === 'iconvalue') {
+        const rendererIcon = icon || firstNonEmptyString(def.icon);
+        const affixes = resolveSemanticPresentationAffixes(presentation);
+        const hasAffixes = !!(affixes.prefix || affixes.suffix);
+        if (!rendererIcon && !hasAffixes)
+            return undefined;
+        return {
+            type: 'icon',
+            icon: {
+                ...(rendererIcon && !hasAffixes ? { name: rendererIcon } : {}),
+                textField: def.name,
+                ...(tooltipText ? { ariaLabel: tooltipText } : {}),
+                ...affixes,
+            },
+        };
+    }
+    return undefined;
+}
+function resolveSemanticPresentationColor(tone) {
+    const normalized = normalizePresentationToken(tone);
+    if (!normalized || normalized === 'neutral')
+        return undefined;
+    return normalized === 'danger' ? 'warn' : normalized;
+}
+function resolveSemanticPresentationVariant(appearance) {
+    const normalized = normalizePresentationToken(appearance);
+    return normalized === 'filled' || normalized === 'outlined' || normalized === 'soft'
+        ? normalized
+        : undefined;
+}
+function resolveSemanticPresentationAffixes(presentation) {
+    const prefix = firstNonEmptyString(presentation.prefix);
+    const suffix = firstNonEmptyString(presentation.suffix);
+    return {
+        ...(prefix ? { prefix } : {}),
+        ...(suffix ? { suffix } : {}),
+    };
+}
+function firstNonEmptyString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizePresentationToken(value) {
+    return String(value ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '');
+}
+function isColumnType(value) {
+    return [
+        'string',
+        'number',
+        'date',
+        'boolean',
+        'currency',
+        'percentage',
+        'custom',
+    ].includes(value);
+}
+function isTextualControlType(value) {
+    return [
+        'input',
+        'inlineinput',
+        'textarea',
+        'search',
+        'email',
+        'url',
+        'phone',
+        'cpfcnpjinput',
+        'password',
+    ].includes(value);
+}
+
+/** Owner-only schema calculation surface; admission must precede executable metadata. */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { deepMerge, isPraxisPresentationVisualizationTableSafe, normalizeSchemaFields, resolveColumnTypeFromFieldDefinition, resolveTextMaskFormatFromFieldDefinition };