@praxisui/metadata-editor 10.0.0-rc.31 → 10.0.0-rc.33

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-10-16T17:45:27.774Z",
+  "generatedAt": "2026-10-18T21:58:32.782Z",
   "packageName": "@praxisui/metadata-editor",
-  "packageVersion": "10.0.0-rc.31",
+  "packageVersion": "10.0.0-rc.33",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 1,

package/fesm2022/praxisui-metadata-editor.mjs

@@ -6,7 +6,7 @@ import * as i3$2 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { isValidCssColor, DynamicFieldLoaderDirective, normalizeCssColorToRgb, providePraxisDynamicFieldsI18n } from '@praxisui/dynamic-fields';
 import * as i2$2 from '@praxisui/core';
-import { providePraxisI18n, PraxisI18nService, PraxisIconDirective, FieldControlType, INLINE_FILTER_CONTROL_TYPES, resolveInlineFilterControlType, normalizeControlTypeToken, normalizeReactiveDeterminations, ComponentMetadataRegistry } from '@praxisui/core';
+import { providePraxisI18n, PraxisI18nService, PraxisIconDirective, FieldControlType, INLINE_FILTER_CONTROL_TYPES, resolveInlineFilterControlType, ResourceDiscoveryService, normalizeControlTypeToken, providePraxisI18nConfig, RESOURCE_DISCOVERY_I18N_CONFIG, normalizeReactiveDeterminations, ComponentMetadataRegistry } from '@praxisui/core';
 import * as i5$1 from '@angular/material/expansion';
 import { MatExpansionModule } from '@angular/material/expansion';
 import * as i2$1 from '@angular/material/icon';
@@ -26,7 +26,7 @@ import { MatInputModule } from '@angular/material/input';
 import * as i6 from '@angular/material/select';
 import { MatSelectModule } from '@angular/material/select';
 import { SETTINGS_PANEL_DATA } from '@praxisui/settings-panel';
-import { BehaviorSubject } from 'rxjs';
+import { Subject, BehaviorSubject, takeUntil, catchError, of } from 'rxjs';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { MatChipsModule } from '@angular/material/chips';
 import { MatDividerModule } from '@angular/material/divider';
@@ -103,14 +103,11 @@ class SchemaNormalizerService {
             if (seed && clone.defaultValue === undefined) {
                 const val = this.getByPath(seed, clone.name);
                 if (val !== undefined) {
-                    // Stringify complex defaults for textarea-friendly editors
-                    const needsJson = (clone.editorType === 'textarea' &&
-                        (clone.name === 'options' ||
-                            clone.name === 'filterCriteria' ||
-                            clone.name === 'paletteSettings.colors' ||
-                            clone.name === 'views' ||
-                            clone.name === 'adaptiveSubtitle'));
-                    clone.defaultValue = needsJson && typeof val !== 'string' ? JSON.stringify(val, null, 2) : val;
+                    // Stringify complex defaults (arrays/objects) for textarea-friendly JSON editors
+                    const needsJson = clone.editorType === 'textarea' &&
+                        val !== null &&
+                        typeof val === 'object';
+                    clone.defaultValue = needsJson ? JSON.stringify(val, null, 2) : val;
                     try {
                         if (clone.name === 'resourcePath' ||
                             clone.name === 'filterCriteria' ||
@@ -443,6 +440,7 @@ const METADATA_EDITOR_EN_US = {
     'praxis.metadataEditor.arrayFields.control.date': 'Date',
     'praxis.metadataEditor.fieldResource.label': 'Governed resource',
     'praxis.metadataEditor.fieldResource.searchPlaceholder': 'Search by name, domain, or path',
+    'praxis.metadataEditor.fieldResource.fieldSearchPlaceholder': 'Search field by name or label',
     'praxis.metadataEditor.fieldResource.hint': 'Select from the host governed catalog. The saved value remains resourcePath.',
     'praxis.metadataEditor.common.help': 'Help',
     'praxis.metadataEditor.common.iconMaterialSymbolsHint': 'Use the icon name (Material Symbols)',
@@ -694,6 +692,7 @@ const METADATA_EDITOR_PT_BR = {
     'praxis.metadataEditor.arrayFields.control.date': 'Data',
     'praxis.metadataEditor.fieldResource.label': 'Recurso governado',
     'praxis.metadataEditor.fieldResource.searchPlaceholder': 'Buscar por nome, dom\u00ednio ou caminho',
+    'praxis.metadataEditor.fieldResource.fieldSearchPlaceholder': 'Buscar campo por nome ou r\u00f3tulo',
     'praxis.metadataEditor.fieldResource.hint': 'Selecione no cat\u00e1logo governado do host. O valor gravado continua sendo resourcePath.',
     'praxis.metadataEditor.common.help': 'Ajuda',
     'praxis.metadataEditor.common.iconMaterialSymbolsHint': 'Use o nome do \u00edcone (Material Symbols)',
@@ -2721,6 +2720,9 @@ class DynamicEditorRendererComponent {
         return options.map((option) => ({
             ...option,
             text: this.resolveEditorText(option.textKey, option.text) ?? option.text,
+            code: option.code ?? undefined,
+            badge: option.badge ?? undefined,
+            description: option.description ?? undefined,
         }));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicEditorRendererComponent, deps: [{ token: i1$1.MatDialog }, { token: i2$2.IconPickerService }, { token: i2$2.PraxisI18nService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
@@ -5546,6 +5548,46 @@ const numberProperties = [
     { name: 'step', label: 'Step (incremento)', editorType: 'number', group: 'Formato/Comportamento', hint: 'Incremento em unidades; combine com min/max (ex.: 0.01).' },
     { name: 'numberFormat.decimalPlaces', label: 'Casas decimais', editorType: 'number', group: 'Formato/Comportamento', row: 'formato.decimais', inline: true, hint: 'Precisão exibida/aceita (ex.: 2).' },
     { name: 'showGrouping', label: 'Agrupar milhares', editorType: 'checkbox', group: 'Formato/Comportamento', row: 'formato.decimais', inline: true, hint: 'Mostra separador de milhar sem alterar o valor salvo.' },
+    { name: 'numberFormat.percentage', label: 'Modo Percentual (Percent Studio)', editorType: 'checkbox', group: 'Formato/Comportamento', hint: 'Ativa pílula de progresso, micro-anel interativo e barra/popover visual de seleção de percentual.' },
+    {
+        name: 'numericFormat',
+        label: 'Formato numérico canônico',
+        editorType: 'select',
+        group: 'Formato/Comportamento',
+        options: [
+            { value: 'decimal', text: 'Decimal' },
+            { value: 'integer', text: 'Inteiro' },
+            { value: 'currency', text: 'Moeda' },
+            { value: 'percent', text: 'Percentual (Percent Studio)' },
+            { value: 'scientific', text: 'Científico' },
+        ],
+        hint: 'Formato semântico do campo numérico vindo do contrato x-ui.',
+    },
+    {
+        name: 'showPercentStudio',
+        label: 'Exibir barra Percent Studio no formulário',
+        editorType: 'checkbox',
+        group: 'Formato/Comportamento',
+        hint: 'Mostra o trilho interativo, presets de quartis e steppers rápidos abaixo do pdx-number-input quando em modo percentual.',
+    },
+    {
+        name: 'inlineVisualStyle',
+        label: 'Estilo visual inline (percentual)',
+        editorType: 'select',
+        group: 'Formato/Comportamento',
+        options: [
+            { value: 'compact', text: 'Compacto (Pílula líquida + popover)' },
+            { value: 'graphic', text: 'Gráfico expandido (Card com donut + slider)' },
+        ],
+        hint: 'Define a apresentação de filtros numéricos percentuais em superfícies inline.',
+    },
+    {
+        name: 'percentPresets',
+        label: 'Presets rápidos de percentual',
+        editorType: 'json',
+        group: 'Formato/Comportamento',
+        hint: 'Lista de atalhos rápidos no Percent Studio (ex.: [0, 25, 50, 75, 100] ou [{"label": "Meta", "value": 12.5}]).',
+    },
     {
         name: 'inputMode',
         label: 'Modo de entrada',
@@ -7718,6 +7760,7 @@ const rangeSliderProperties = [
             { value: 'compact', text: 'Compacto' },
             { value: 'storage', text: 'Armazenamento' },
         ], hint: 'Formatter declarativo para labels e aria-valuetext.' },
+    { name: 'numberFormat.percentage', label: 'Percentual (%)', editorType: 'checkbox', group: 'Formato/Comportamento', hint: 'Ativa apresentação Percent Studio (pílula líquida de intervalo, micro-anel e quartis automáticos 0%–100%).' },
     { name: 'showTicks', label: 'Ticks', editorType: 'select', group: 'Formato/Comportamento', options: [
             { value: false, text: 'Sem ticks' },
             { value: true, text: 'Com ticks' },
@@ -10732,6 +10775,93 @@ function mergeEditorProperties(base, contextual) {
     }
     return merged;
 }
+const inlinePhoneEditorProperties = mergeEditorProperties(inputProperties, phoneInputProperties);
+const inlinePeriodRangeEditorProperties = mergeEditorProperties(rangeSliderProperties, [
+    {
+        name: 'granularity',
+        label: 'Granularidade do período',
+        editorType: 'select',
+        group: 'Formato/Comportamento',
+        options: [
+            { value: 'month', text: 'Mês (1-12 ou YYYY-MM)' },
+            { value: 'year', text: 'Ano (YYYY)' },
+        ],
+        hint: 'Define se o seletor opera em competência mensal ou exercício anual.',
+    },
+    {
+        name: 'defaultGranularity',
+        label: 'Granularidade inicial',
+        editorType: 'select',
+        group: 'Formato/Comportamento',
+        options: [
+            { value: 'month', text: 'Mês' },
+            { value: 'year', text: 'Ano' },
+        ],
+        hint: 'Granularidade inicial aberta no painel.',
+    },
+    {
+        name: 'selectionGrid',
+        label: 'Exibir grade de seleção (Jan-Dez / Anos)',
+        editorType: 'checkbox',
+        group: 'Formato/Comportamento',
+        hint: 'Mostra botões clicáveis de meses ou anos para seleção de único item ou faixa.',
+    },
+    {
+        name: 'showSlider',
+        label: 'Exibir slider complementar',
+        editorType: 'checkbox',
+        group: 'Formato/Comportamento',
+        hint: 'Mostra barra deslizante sincronizada com a grade de meses/anos.',
+    },
+    {
+        name: 'inlineChipDisplay',
+        label: 'Exibição no chip (inline)',
+        editorType: 'select',
+        group: 'Formato/Comportamento',
+        options: [
+            { value: 'badge', text: 'Rótulo + badge (ex.: Mês: Jan – Jun)' },
+            { value: 'value', text: 'Apenas valor (ex.: Jan – Jun)' },
+            { value: 'label-value', text: 'Rótulo + valor' },
+        ],
+        hint: 'Define como o intervalo selecionado aparece na pílula fechada.',
+    },
+    {
+        name: 'minYear',
+        label: 'Ano mínimo',
+        editorType: 'number',
+        group: 'Validação',
+        row: 'val.yearminmax',
+        inline: true,
+        hint: 'Ano inicial exibido na grade de anos (ex.: 2020).',
+    },
+    {
+        name: 'maxYear',
+        label: 'Ano máximo',
+        editorType: 'number',
+        group: 'Validação',
+        row: 'val.yearminmax',
+        inline: true,
+        hint: 'Ano final exibido na grade de anos (ex.: 2030).',
+    },
+    {
+        name: 'minPeriod',
+        label: 'Período mínimo',
+        editorType: 'text',
+        group: 'Validação',
+        row: 'val.periodminmax',
+        inline: true,
+        hint: 'Limite inferior de competência (ex.: 2020-01 ou 1).',
+    },
+    {
+        name: 'maxPeriod',
+        label: 'Período máximo',
+        editorType: 'text',
+        group: 'Validação',
+        row: 'val.periodminmax',
+        inline: true,
+        hint: 'Limite superior de competência (ex.: 2027-12 ou 12).',
+    },
+]);
 function hasCanonicalDocumentSemantics(metadata) {
     if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
         return false;
@@ -10747,12 +10877,12 @@ const INLINE_FILTER_EDITOR_PROPERTIES_BY_CONTROL_TYPE = Object.freeze({
     [INLINE_FILTER_CONTROL_TYPES.AUTOCOMPLETE]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.MULTI_SELECT]: selectProperties,
     [INLINE_FILTER_CONTROL_TYPES.INPUT]: inputProperties,
-    [INLINE_FILTER_CONTROL_TYPES.PHONE]: inputProperties,
+    [INLINE_FILTER_CONTROL_TYPES.PHONE]: inlinePhoneEditorProperties,
     [INLINE_FILTER_CONTROL_TYPES.TOGGLE]: toggleProperties,
     [INLINE_FILTER_CONTROL_TYPES.RANGE]: rangeSliderProperties,
-    [INLINE_FILTER_CONTROL_TYPES.PERIOD_RANGE]: rangeSliderProperties,
-    [INLINE_FILTER_CONTROL_TYPES.YEAR_RANGE]: rangeSliderProperties,
-    [INLINE_FILTER_CONTROL_TYPES.MONTH_RANGE]: rangeSliderProperties,
+    [INLINE_FILTER_CONTROL_TYPES.PERIOD_RANGE]: inlinePeriodRangeEditorProperties,
+    [INLINE_FILTER_CONTROL_TYPES.YEAR_RANGE]: inlinePeriodRangeEditorProperties,
+    [INLINE_FILTER_CONTROL_TYPES.MONTH_RANGE]: inlinePeriodRangeEditorProperties,
     [INLINE_FILTER_CONTROL_TYPES.DATE]: dateProperties,
     [INLINE_FILTER_CONTROL_TYPES.DATE_RANGE]: dateRangeProperties,
     [INLINE_FILTER_CONTROL_TYPES.TIME]: timePickerProperties,
@@ -10794,7 +10924,10 @@ class FieldMetadataEditorComponent {
     normalizedProps = [];
     renderedProps = [];
     initialSnapshot = null;
+    initialControlType;
     baselineReady = false;
+    formRebuild$ = new Subject();
+    hostApplyPatch;
     // Lista de tipos suportados no editor (curada para os tipos com config disponível)
     typeOptions = [
         { value: FieldControlType.INPUT, label: 'Texto (Input)' },
@@ -10847,6 +10980,9 @@ class FieldMetadataEditorComponent {
     isValid$ = new BehaviorSubject(true);
     isBusy$ = new BehaviorSubject(false);
     destroyRef = inject(DestroyRef);
+    resourceDiscovery = inject(ResourceDiscoveryService, { optional: true });
+    i18n = inject(PraxisI18nService, { optional: true });
+    discoveredResourceOptions = [];
     lastCurrencyPreset = null;
     constructor(registry, normalizer, factory, ctxValidators) {
         this.registry = registry;
@@ -10861,10 +10997,7 @@ class FieldMetadataEditorComponent {
             if (data.seed)
                 this.seed = data.seed;
             // Bridge: allow host to receive patches even if saved$/applied$ are missed
-            try {
-                this.__hostApplyPatch = data.hostBridge?.applyPatch;
-            }
-            catch { }
+            this.hostApplyPatch = data.hostBridge?.applyPatch;
         }
         // Normalize legacy avatar seed (root imageSrc/imageAlt -> extra.* for editor binding)
         try {
@@ -10886,14 +11019,145 @@ class FieldMetadataEditorComponent {
         }
         catch { }
     }
+    catalogLookupRequested = false;
+    resourceSchemaFieldsByPath = new Map();
+    resourceSchemaRequestIdByScope = {
+        root: 0,
+        optionSource: 0,
+    };
     ngOnInit() {
-        try {
-            const hasBridge = typeof this.__hostApplyPatch === 'function';
-            (console.log || console.debug)('[FieldMetadataEditor] ngOnInit', { controlType: this.controlType, hasHostBridge: hasBridge });
-        }
-        catch { }
         this.rebuildEditorForType(this.controlType);
     }
+    loadCatalogResourceOptionsIfNeeded() {
+        const hasResourcePathProp = this.normalizedProps.some((prop) => prop?.name === 'resourcePath' ||
+            prop?.name === 'optionSource.resourcePath');
+        if (!hasResourcePathProp) {
+            return;
+        }
+        const optionSourceTypeCtrl = this.form?.get('optionSource.type');
+        if (optionSourceTypeCtrl) {
+            optionSourceTypeCtrl.valueChanges
+                .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
+                .subscribe(() => {
+                if (this.discoveredResourceOptions.length > 0 && this.normalizedProps.length > 0) {
+                    this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+                }
+            });
+        }
+        this.bindResourcePathSchemaSync('resourcePath', 'root');
+        this.bindResourcePathSchemaSync('optionSource.resourcePath', 'optionSource');
+        if (this.catalogLookupRequested || !this.resourceDiscovery) {
+            return;
+        }
+        this.catalogLookupRequested = true;
+        const endpointKey = this.resolveDiscoveryEndpointKey();
+        this.resourceDiscovery
+            .getDiscoveredResources({
+            intent: 'any',
+            ...(endpointKey ? { endpointKey } : {}),
+        })
+            .pipe(catchError(() => of([])), takeUntilDestroyed(this.destroyRef))
+            .subscribe((options) => {
+            this.discoveredResourceOptions = options;
+            this.seedCatalogResponseFieldsCache(options);
+            if (options.length > 0 && this.normalizedProps.length > 0) {
+                this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+            }
+        });
+    }
+    resolveDiscoveryEndpointKey() {
+        const raw = this.form?.get('endpointKey')?.value ??
+            this.form?.get('apiEndpointKey')?.value ??
+            this.seed?.endpointKey ??
+            this.seed?.apiEndpointKey;
+        const trimmed = String(raw ?? '').trim();
+        return trimmed || undefined;
+    }
+    bindResourcePathSchemaSync(controlPath, scope) {
+        const ctrl = this.form?.get(controlPath);
+        if (!ctrl) {
+            return;
+        }
+        let lastPath = String(ctrl.value ?? '').trim();
+        if (lastPath) {
+            this.resolveAndApplyResourceSchemaFields(lastPath, scope, false);
+        }
+        ctrl.valueChanges
+            .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
+            .subscribe((nextValue) => {
+            const nextPath = String(nextValue ?? '').trim();
+            if (nextPath === lastPath) {
+                return;
+            }
+            lastPath = nextPath;
+            if (!nextPath) {
+                if (this.normalizedProps.length > 0) {
+                    this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+                }
+                return;
+            }
+            this.resolveAndApplyResourceSchemaFields(nextPath, scope, this.baselineReady);
+        });
+    }
+    seedCatalogResponseFieldsCache(options) {
+        for (const option of options) {
+            if (!option?.responseFields?.length) {
+                continue;
+            }
+            const key = this.normalizeResourceCacheKey(option.value);
+            if (key && !this.resourceSchemaFieldsByPath.has(key)) {
+                this.resourceSchemaFieldsByPath.set(key, option.responseFields
+                    .filter((field) => Boolean(field?.name && String(field.name).trim()))
+                    .map((field) => ({
+                    name: String(field.name).trim(),
+                    label: String(field.label ?? '').trim() || String(field.name).trim(),
+                    type: String(field.type ?? field.controlType ?? 'string').trim() || 'string',
+                    controlType: String(field.controlType ?? '').trim() || undefined,
+                    description: String(field.description ?? '').trim() || undefined,
+                })));
+            }
+        }
+    }
+    resolveAndApplyResourceSchemaFields(resourcePath, scope, autoSuggestDefaults) {
+        const trimmed = String(resourcePath ?? '').trim();
+        if (!trimmed) {
+            return;
+        }
+        const cached = this.getCachedFieldsForResource(trimmed);
+        if (cached.length > 0) {
+            if (autoSuggestDefaults) {
+                this.applyAutoSuggestedDependentKeys(scope, cached);
+            }
+            if (this.normalizedProps.length > 0) {
+                this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+            }
+        }
+        if (typeof this.resourceDiscovery?.getResourceSchemaFields !== 'function') {
+            return;
+        }
+        const requestId = ++this.resourceSchemaRequestIdByScope[scope];
+        const endpointKey = this.resolveDiscoveryEndpointKey();
+        const request$ = endpointKey
+            ? this.resourceDiscovery.getResourceSchemaFields(trimmed, { endpointKey })
+            : this.resourceDiscovery.getResourceSchemaFields(trimmed);
+        request$
+            .pipe(catchError(() => of([])), takeUntilDestroyed(this.destroyRef))
+            .subscribe((fields) => {
+            if (requestId !== this.resourceSchemaRequestIdByScope[scope]) {
+                return;
+            }
+            const validFields = (fields || []).filter((field) => Boolean(field?.name && String(field.name).trim()));
+            if (validFields.length > 0) {
+                this.setCachedFieldsForResource(trimmed, validFields);
+                if (autoSuggestDefaults) {
+                    this.applyAutoSuggestedDependentKeys(scope, validFields);
+                }
+            }
+            if (this.normalizedProps.length > 0) {
+                this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+            }
+        });
+    }
     resolveCanonicalEditorProperties(controlType, controlTypeToken) {
         const inlineProps = resolveInlineFilterEditorProperties(controlTypeToken, this.seed);
         if (inlineProps?.length)
@@ -10988,6 +11252,10 @@ class FieldMetadataEditorComponent {
         return undefined;
     }
     rebuildEditorForType(ct) {
+        this.formRebuild$.next();
+        if (this.initialControlType === undefined) {
+            this.initialControlType = ct;
+        }
         this.controlType = ct;
         let props = this.registry.getProperties(this.controlType);
         const controlTypeToken = normalizeControlTypeToken(this.controlType);
@@ -11008,23 +11276,6 @@ class FieldMetadataEditorComponent {
                 }
             }
         }
-        try {
-            (console.log || console.debug)('[FieldMetadataEditor] init', {
-                controlType: this.controlType,
-                seedPreview: {
-                    resourcePath: this.seed?.resourcePath,
-                    optionLabelKey: this.seed?.optionLabelKey,
-                    optionValueKey: this.seed?.optionValueKey,
-                    filterCriteria: typeof this.seed?.filterCriteria === 'string'
-                        ? this.seed?.filterCriteria
-                        : this.seed?.filterCriteria != null
-                            ? JSON.stringify(this.seed?.filterCriteria)
-                            : undefined,
-                },
-                propsBefore: props.map((p) => p.name),
-            });
-        }
-        catch { }
         // Fallback de registro mínimo para facilitar execução inicial
         if (!props.length && canonicalProps?.length) {
             this.registry.register(this.controlType, canonicalProps);
@@ -11197,12 +11448,6 @@ class FieldMetadataEditorComponent {
                 props = treeSelectProperties;
             }
         }
-        try {
-            (console.log || console.debug)('[FieldMetadataEditor] props after registry resolution', {
-                resolvedProps: props.map((p) => p.name),
-            });
-        }
-        catch { }
         // Inject controlType selector into 'Geral' group so users can change field type
         try {
             const typeProp = {
@@ -11221,28 +11466,6 @@ class FieldMetadataEditorComponent {
         }
         catch { }
         this.normalizedProps = this.normalizer.normalize(props, this.seed);
-        try {
-            console.debug('[FieldMetadataEditor] normalized props', {
-                propNames: this.normalizedProps.map((p) => p.name),
-                defaults: this.normalizedProps
-                    .filter((p) => ['resourcePath', 'filterCriteria', 'optionLabelKey', 'optionValueKey'].includes(p.name))
-                    .map((p) => ({ name: p.name, defaultValue: p.defaultValue })),
-                optionsDefault: (() => {
-                    const opt = this.normalizedProps.find((p) => p.name === 'options');
-                    if (!opt)
-                        return undefined;
-                    const v = opt.defaultValue;
-                    return {
-                        type: v == null ? 'null' : typeof v,
-                        preview: typeof v === 'string' ? String(v).slice(0, 80) : undefined,
-                        lengthOrCount: Array.isArray(v)
-                            ? v.length
-                            : (typeof v === 'string' ? v.length : undefined),
-                    };
-                })(),
-            });
-        }
-        catch { }
         // Backward-compatible bridge: if a config still uses providerOptions, hydrate from seed.options.
         try {
             const hasProviderOptions = this.normalizedProps.some((p) => p.name === 'providerOptions');
@@ -11255,10 +11478,6 @@ class FieldMetadataEditorComponent {
                     return String(seedOptions);
                 } })();
                 this.normalizedProps = this.normalizedProps.map((p) => p.name === 'providerOptions' && p.defaultValue === undefined ? { ...p, defaultValue: v } : p);
-                (console.log || console.debug)('[FieldMetadataEditor] providerOptions default injected from seed.options', {
-                    type: typeof seedOptions,
-                    lengthOrCount: Array.isArray(seedOptions) ? seedOptions.length : (typeof seedOptions === 'string' ? seedOptions.length : undefined),
-                });
             }
         }
         catch { }
@@ -11305,61 +11524,19 @@ class FieldMetadataEditorComponent {
                 this.form.patchValue(subset, { emitEvent: false });
             }
             catch { }
-            // Diagnostics for Rating seeding after applying seed → form
-            try {
-                const ctU = String(this.controlType || '').toUpperCase();
-                if (ctU === String(FieldControlType.RATING)) {
-                    const pick = (k) => this.form.get(k)?.value;
-                    console.debug('[FieldMetadataEditor][RATING] seeded form values', {
-                        max: pick('max'),
-                        allowHalf: pick('allowHalf'),
-                        selection: pick('selection'),
-                        size: pick('size'),
-                        icon: pick('icon'),
-                        emptyIcon: pick('emptyIcon'),
-                        svgIcon: pick('svgIcon'),
-                        svgIconOutline: pick('svgIconOutline'),
-                        ratingColor: pick('ratingColor'),
-                        outlineColor: pick('outlineColor'),
-                        readonly: pick('readonly'),
-                        tabIndex: pick('tabIndex'),
-                        ariaLabel: pick('ariaLabel'),
-                    });
-                }
-            }
-            catch { }
-        }
-        catch { }
-        // Diagnostics: dump initial values for Rating editor
-        try {
-            const ctU = String(this.controlType || '').toUpperCase();
-            if (ctU === String(FieldControlType.RATING)) {
-                const pick = (k) => this.form.get(k)?.value;
-                console.debug('[FieldMetadataEditor][RATING] initial form values', {
-                    max: pick('max'),
-                    allowHalf: pick('allowHalf'),
-                    selection: pick('selection'),
-                    size: pick('size'),
-                    icon: pick('icon'),
-                    emptyIcon: pick('emptyIcon'),
-                    svgIcon: pick('svgIcon'),
-                    svgIconOutline: pick('svgIconOutline'),
-                    ratingColor: pick('ratingColor'),
-                    outlineColor: pick('outlineColor'),
-                    readonly: pick('readonly'),
-                    tabIndex: pick('tabIndex'),
-                    ariaLabel: pick('ariaLabel'),
-                });
-            }
         }
         catch { }
         // Capture baseline after seed is applied to avoid missing first user change
         try {
-            this.initialSnapshot = this.form.getRawValue();
+            if (this.initialSnapshot == null) {
+                this.initialSnapshot = this.form.getRawValue();
+            }
             this.baselineReady = true;
-            if (this.isDirty$.value)
+            const controlTypeChanged = this.initialControlType !== undefined &&
+                this.controlType !== this.initialControlType;
+            if (!controlTypeChanged && this.isDirty$.value) {
                 this.isDirty$.next(false);
-            (console.log || console.debug)('[FieldMetadataEditor] baseline captured (immediate)');
+            }
         }
         catch {
             this.baselineReady = true;
@@ -11367,12 +11544,12 @@ class FieldMetadataEditorComponent {
         // track validity/dirty with snapshot-based detection (avoid false dirty on init)
         this.isValid$.next(this.form.valid);
         this.form.statusChanges
-            .pipe(takeUntilDestroyed(this.destroyRef))
+            .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
             .subscribe(() => this.isValid$.next(this.form.valid));
         this.setupGradientStopValidationSync();
         this.setupCurrencyPresetSync();
         this.form.valueChanges
-            .pipe(takeUntilDestroyed(this.destroyRef))
+            .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
             .subscribe((val) => {
             if (!this.baselineReady) {
                 // Ignore initial churn until baseline is captured
@@ -11382,12 +11559,10 @@ class FieldMetadataEditorComponent {
                 this.initialSnapshot = val;
                 if (this.isDirty$.value)
                     this.isDirty$.next(false);
-                try {
-                    (console.log || console.debug)('[FieldMetadataEditor] baseline set from first stable value');
-                }
-                catch { }
                 return;
             }
+            const controlTypeChanged = this.initialControlType !== undefined &&
+                this.controlType !== this.initialControlType;
             let same = false;
             try {
                 same = JSON.stringify(val) === JSON.stringify(this.initialSnapshot);
@@ -11395,15 +11570,15 @@ class FieldMetadataEditorComponent {
             catch {
                 same = false;
             }
-            const dirty = !same;
+            const dirty = controlTypeChanged || !same;
             if (dirty !== this.isDirty$.value) {
-                try {
-                    (console.log || console.debug)('[FieldMetadataEditor] dirty ->', dirty);
-                }
-                catch { }
                 this.isDirty$.next(dirty);
             }
         });
+        if (this.discoveredResourceOptions.length > 0) {
+            this.renderedProps = this.buildRenderedProps(this.normalizedProps);
+        }
+        this.loadCatalogResourceOptionsIfNeeded();
     }
     setupGradientStopValidationSync() {
         const rows = new Map();
@@ -11419,7 +11594,7 @@ class FieldMetadataEditorComponent {
                 if (!source)
                     continue;
                 source.valueChanges
-                    .pipe(takeUntilDestroyed(this.destroyRef))
+                    .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
                     .subscribe(() => {
                     for (const targetField of fieldNames) {
                         if (targetField === sourceField)
@@ -11471,7 +11646,7 @@ class FieldMetadataEditorComponent {
             VES: { locale: 'es-VE', decimalPlaces: 2, currencyPosition: 'before' },
         };
         currencyControl.valueChanges
-            .pipe(takeUntilDestroyed(this.destroyRef))
+            .pipe(takeUntil(this.formRebuild$), takeUntilDestroyed(this.destroyRef))
             .subscribe((value) => {
             const code = String(value || '').toUpperCase();
             const preset = presets[code];
@@ -11522,13 +11697,7 @@ class FieldMetadataEditorComponent {
         // Sempre incluir controlType no patch quando presente
         patch.controlType = this.controlType;
         try {
-            console.debug('[FieldMetadataEditor] apply() patch', patch);
-        }
-        catch { }
-        try {
-            const fn = this.__hostApplyPatch;
-            if (typeof fn === 'function')
-                fn(patch);
+            this.hostApplyPatch?.(patch);
         }
         catch { }
         this.applied.emit(patch);
@@ -11549,10 +11718,6 @@ class FieldMetadataEditorComponent {
             delete patch.providerOptions;
         }
         patch.controlType = this.controlType;
-        try {
-            console.debug('[FieldMetadataEditor] getSettingsValue() patch', patch);
-        }
-        catch { }
         return patch;
     }
     /**
@@ -11834,6 +11999,9 @@ class FieldMetadataEditorComponent {
         }
     }
     reset() {
+        if (this.initialControlType !== undefined && this.controlType !== this.initialControlType) {
+            this.rebuildEditorForType(this.initialControlType);
+        }
         const snapshot = this.cloneSnapshot(this.initialSnapshot ?? this.form.getRawValue());
         this.form.reset(snapshot);
         this.form.markAsPristine();
@@ -11860,11 +12028,321 @@ class FieldMetadataEditorComponent {
     get isArrayEditor() {
         return this.controlType === FieldControlType.ARRAY_INPUT;
     }
+    static ROOT_DEPENDENT_FIELD_KEY_PROPS = new Set([
+        'optionValueKey',
+        'optionLabelKey',
+        'lookupIdKey',
+        'lookupLabelKey',
+        'lookupSubtitleKey',
+        'parentIdKey',
+    ]);
+    static OPTION_SOURCE_DEPENDENT_FIELD_KEY_PROPS = new Set([
+        'optionSource.valuePropertyPath',
+        'optionSource.labelPropertyPath',
+        'optionSource.codePropertyPath',
+        'optionSource.statusPropertyPath',
+        'optionSource.subtitlePropertyPath',
+        'optionSource.descriptionPropertyPath',
+    ]);
     buildRenderedProps(props) {
-        if (!this.isArrayEditor) {
-            return props;
+        const base = !this.isArrayEditor
+            ? props || []
+            : (props || []).filter((prop) => prop?.name !== 'array.itemSchema.fields');
+        if (!this.discoveredResourceOptions.length &&
+            this.resourceSchemaFieldsByPath.size === 0) {
+            return base;
+        }
+        return base.map((prop) => {
+            const resourceEnriched = this.enrichResourcePathProperty(prop);
+            return this.enrichDependentFieldKeyProperty(resourceEnriched);
+        });
+    }
+    enrichResourcePathProperty(prop) {
+        if (!prop ||
+            (prop.name !== 'resourcePath' && prop.name !== 'optionSource.resourcePath')) {
+            return prop;
+        }
+        const optionSourceType = String(this.form?.get('optionSource.type')?.value ??
+            this.seed?.optionSource?.type ??
+            '')
+            .trim()
+            .toLowerCase();
+        const useStatsIntent = prop.name === 'optionSource.resourcePath' && optionSourceType === 'stats';
+        const filteredResources = this.discoveredResourceOptions.filter((item) => useStatsIntent
+            ? item.capabilities?.stats !== false
+            : item.capabilities?.options !== false);
+        if (!filteredResources.length) {
+            return prop;
+        }
+        const currentValue = String(this.form?.get(prop.name)?.value ?? prop.defaultValue ?? '').trim();
+        const matchedCatalogOption = currentValue
+            ? this.resourceDiscovery?.findCatalogResourceOption?.(currentValue, filteredResources)
+            : null;
+        const readOnlyLabel = this.i18n?.t('quickConnect.readOnly', undefined, 'Somente leitura', 'resourceDiscovery') ?? 'Somente leitura';
+        const options = filteredResources.map((item) => {
+            const readOnlySuffix = item.readOnly ? readOnlyLabel : null;
+            const hasDistinctPath = Boolean(item.path && item.path !== item.label);
+            const code = hasDistinctPath ? item.path : null;
+            const badge = [item.group, readOnlySuffix]
+                .filter((part) => Boolean(part))
+                .join(' · ') || null;
+            const description = String(item.description ?? '').trim() || null;
+            return {
+                value: item === matchedCatalogOption && currentValue ? currentValue : item.value,
+                text: item.label,
+                icon: item.icon ?? 'api',
+                code,
+                badge,
+                description,
+                searchTerms: [
+                    ...item.searchTerms,
+                    ...(readOnlySuffix ? [readOnlySuffix] : []),
+                ],
+            };
+        });
+        if (currentValue && !matchedCatalogOption) {
+            options.unshift({
+                value: currentValue,
+                text: currentValue,
+                icon: 'link',
+                code: null,
+                badge: null,
+                description: null,
+                searchTerms: [currentValue],
+            });
+        }
+        return {
+            ...prop,
+            editorType: 'select',
+            searchable: true,
+            searchPlaceholderKey: 'fieldResource.searchPlaceholder',
+            searchPlaceholder: 'Buscar por nome, domínio ou caminho',
+            options,
+        };
+    }
+    enrichDependentFieldKeyProperty(prop) {
+        const propName = String(prop?.name ?? '').trim();
+        const isRootDependent = FieldMetadataEditorComponent.ROOT_DEPENDENT_FIELD_KEY_PROPS.has(propName);
+        const isOptionSourceDependent = FieldMetadataEditorComponent.OPTION_SOURCE_DEPENDENT_FIELD_KEY_PROPS.has(propName);
+        if (!isRootDependent && !isOptionSourceDependent) {
+            return prop;
+        }
+        const resourceControlPath = isOptionSourceDependent
+            ? 'optionSource.resourcePath'
+            : 'resourcePath';
+        const resourcePath = String(this.form?.get(resourceControlPath)?.value ??
+            (isOptionSourceDependent
+                ? this.seed?.optionSource?.resourcePath
+                : this.seed?.resourcePath) ??
+            '').trim();
+        if (!resourcePath) {
+            return prop;
+        }
+        const fields = this.getCachedFieldsForResource(resourcePath);
+        if (!fields.length) {
+            return prop;
+        }
+        const currentValue = String(this.form?.get(propName)?.value ?? prop.defaultValue ?? '').trim();
+        const options = fields.map((field) => {
+            const fieldName = String(field.name ?? '').trim();
+            const fieldLabel = String(field.label ?? '').trim();
+            const hasDistinctLabel = Boolean(fieldLabel && fieldLabel !== fieldName);
+            const typeHint = String(field.type || field.controlType || '').trim();
+            const description = String(field.description ?? '').trim() || null;
+            return {
+                value: fieldName,
+                text: hasDistinctLabel ? fieldLabel : fieldName,
+                code: hasDistinctLabel ? fieldName : null,
+                badge: typeHint || null,
+                description,
+                searchTerms: [
+                    fieldName,
+                    fieldLabel,
+                    typeHint,
+                    description ?? '',
+                ].filter(Boolean),
+            };
+        });
+        if (currentValue &&
+            !options.some((option) => option.value === currentValue)) {
+            options.unshift({
+                value: currentValue,
+                text: currentValue,
+                code: null,
+                badge: null,
+                description: null,
+                searchTerms: [currentValue],
+            });
+        }
+        return {
+            ...prop,
+            editorType: 'select',
+            searchable: true,
+            searchPlaceholderKey: 'fieldResource.fieldSearchPlaceholder',
+            searchPlaceholder: 'Buscar campo por nome ou rótulo',
+            options,
+        };
+    }
+    normalizeResourceCacheKey(resourcePath) {
+        const raw = String(resourcePath ?? '').trim();
+        if (!raw) {
+            return '';
+        }
+        if (this.discoveredResourceOptions.length > 0) {
+            const matched = this.resourceDiscovery?.findCatalogResourceOption?.(raw, this.discoveredResourceOptions);
+            if (matched?.value) {
+                return matched.value.trim().replace(/^\/+|\/+$/g, '');
+            }
+        }
+        return raw.replace(/^\/+|\/+$/g, '').replace(/^api\/+/i, '');
+    }
+    getCachedFieldsForResource(resourcePath) {
+        const key = this.normalizeResourceCacheKey(resourcePath);
+        if (!key) {
+            return [];
+        }
+        const direct = this.resourceSchemaFieldsByPath.get(key);
+        if (direct?.length) {
+            return direct;
+        }
+        const rawKey = String(resourcePath ?? '').trim().replace(/^\/+|\/+$/g, '');
+        return this.resourceSchemaFieldsByPath.get(rawKey) ?? [];
+    }
+    setCachedFieldsForResource(resourcePath, fields) {
+        const key = this.normalizeResourceCacheKey(resourcePath);
+        if (key) {
+            this.resourceSchemaFieldsByPath.set(key, fields);
+        }
+        const rawKey = String(resourcePath ?? '').trim().replace(/^\/+|\/+$/g, '');
+        if (rawKey) {
+            this.resourceSchemaFieldsByPath.set(rawKey, fields);
+        }
+    }
+    applyAutoSuggestedDependentKeys(scope, fields) {
+        if (!this.form || !fields.length) {
+            return;
         }
-        return (props || []).filter((prop) => prop?.name !== 'array.itemSchema.fields');
+        const fieldNameSet = new Set(fields.map((field) => String(field.name ?? '').trim()).filter(Boolean));
+        const suggestions = this.selectSuggestedFieldKeys(fields);
+        const targets = scope === 'optionSource'
+            ? [
+                {
+                    path: 'optionSource.valuePropertyPath',
+                    suggested: suggestions.valueKey,
+                },
+                {
+                    path: 'optionSource.labelPropertyPath',
+                    suggested: suggestions.labelKey,
+                },
+                {
+                    path: 'optionSource.codePropertyPath',
+                    suggested: suggestions.codeKey,
+                },
+                {
+                    path: 'optionSource.statusPropertyPath',
+                    suggested: suggestions.statusKey,
+                },
+            ]
+            : [
+                { path: 'optionValueKey', suggested: suggestions.valueKey },
+                { path: 'optionLabelKey', suggested: suggestions.labelKey },
+                { path: 'lookupIdKey', suggested: suggestions.valueKey },
+                { path: 'lookupLabelKey', suggested: suggestions.labelKey },
+                { path: 'lookupSubtitleKey', suggested: suggestions.subtitleKey },
+            ];
+        for (const target of targets) {
+            const ctrl = this.form.get(target.path);
+            if (!ctrl) {
+                continue;
+            }
+            const current = String(ctrl.value ?? '').trim();
+            if (!current || !fieldNameSet.has(current)) {
+                const nextValue = target.suggested ?? '';
+                if (current !== nextValue) {
+                    ctrl.setValue(nextValue);
+                }
+            }
+        }
+    }
+    selectSuggestedFieldKeys(fields) {
+        const names = fields
+            .map((field) => String(field.name ?? '').trim())
+            .filter(Boolean);
+        const findExact = (candidates, exclude = new Set()) => {
+            for (const candidate of candidates) {
+                const lower = candidate.toLowerCase();
+                const found = names.find((name) => !exclude.has(name) && name.toLowerCase() === lower);
+                if (found) {
+                    return found;
+                }
+            }
+            return null;
+        };
+        const valueKey = findExact([
+            'id',
+            'codigo',
+            'code',
+            'uuid',
+            'key',
+            'valor',
+            'value',
+            'matricula',
+            'sigla',
+        ]) ??
+            names.find((name) => /(?:Id|Codigo|Code)$/.test(name)) ??
+            names[0] ??
+            null;
+        const usedForValue = new Set(valueKey ? [valueKey] : []);
+        const labelKey = findExact([
+            'nome',
+            'name',
+            'label',
+            'descricao',
+            'description',
+            'titulo',
+            'title',
+            'razaosocial',
+            'nomecompleto',
+            'rotulo',
+            'text',
+        ], usedForValue) ??
+            fields
+                .find((field) => !usedForValue.has(String(field.name ?? '').trim()) &&
+                String(field.type ?? 'string').toLowerCase() === 'string')
+                ?.name?.trim() ??
+            names.find((name) => !usedForValue.has(name)) ??
+            valueKey;
+        const codeKey = findExact([
+            'codigo',
+            'code',
+            'sigla',
+            'chave',
+            'matricula',
+            'referencia',
+        ]);
+        const statusKey = findExact([
+            'status',
+            'situacao',
+            'ativo',
+            'active',
+            'estado',
+            'enabled',
+        ]);
+        const usedForPrimary = new Set([valueKey, labelKey].filter((item) => Boolean(item)));
+        const subtitleKey = findExact([
+            'descricao',
+            'description',
+            'subtitulo',
+            'subtitle',
+            'resumo',
+            'summary',
+            'email',
+            'cargo',
+            'departamento',
+            'sigla',
+            'codigo',
+        ], usedForPrimary);
+        return { valueKey, labelKey, codeKey, statusKey, subtitleKey };
     }
     cloneSnapshot(value) {
         return this.cloneMetadataValue(value, new WeakMap());
@@ -11977,6 +12455,7 @@ class FieldMetadataEditorComponent {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldMetadataEditorComponent, deps: [{ token: ConfigRegistryService }, { token: SchemaNormalizerService }, { token: DynamicFormFactoryService }, { token: ContextValidatorRegistryService }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: FieldMetadataEditorComponent, isStandalone: true, selector: "praxis-field-metadata-editor", inputs: { controlType: "controlType", seed: "seed" }, outputs: { applied: "applied", cancel: "cancel" }, providers: [
             providePraxisMetadataEditorI18n(),
+            providePraxisI18nConfig(RESOURCE_DISCOVERY_I18N_CONFIG),
             ...providePraxisDynamicFieldsI18n(),
         ], ngImport: i0, template: `
     @if (form) {
@@ -12007,6 +12486,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     ],
                     providers: [
                         providePraxisMetadataEditorI18n(),
+                        providePraxisI18nConfig(RESOURCE_DISCOVERY_I18N_CONFIG),
                         ...providePraxisDynamicFieldsI18n(),
                     ],
                     template: `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/metadata-editor",
-  "version": "10.0.0-rc.31",
+  "version": "10.0.0-rc.33",
   "description": "Metadata editor for Praxis UI fields and components with runtime integration.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
@@ -8,10 +8,10 @@
     "@angular/cdk": "^21.0.0",
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
-    "@praxisui/ai": "^10.0.0-rc.31",
-    "@praxisui/core": "^10.0.0-rc.31",
-    "@praxisui/dynamic-fields": "^10.0.0-rc.31",
-    "@praxisui/settings-panel": "^10.0.0-rc.31",
+    "@praxisui/ai": "^10.0.0-rc.33",
+    "@praxisui/core": "^10.0.0-rc.33",
+    "@praxisui/dynamic-fields": "^10.0.0-rc.33",
+    "@praxisui/settings-panel": "^10.0.0-rc.33",
     "rxjs": "~7.8.0"
   },
   "dependencies": {

package/types/praxisui-metadata-editor.d.ts

@@ -22,6 +22,11 @@ interface EditorProperty {
         value: any;
         text: string;
         textKey?: string;
+        icon?: string;
+        code?: string | null;
+        badge?: string | null;
+        description?: string | null;
+        searchTerms?: string[];
     }> | {
         type: 'static' | 'http' | 'fn';
         config?: any;
@@ -154,7 +159,10 @@ declare class FieldMetadataEditorComponent implements OnInit {
     normalizedProps: any[];
     renderedProps: any[];
     private initialSnapshot;
+    private initialControlType?;
     private baselineReady;
+    private readonly formRebuild$;
+    private readonly hostApplyPatch?;
     typeOptions: Array<{
         value: FieldControlType;
         label: string;
@@ -163,9 +171,20 @@ declare class FieldMetadataEditorComponent implements OnInit {
     isValid$: BehaviorSubject<boolean>;
     isBusy$: BehaviorSubject<boolean>;
     private readonly destroyRef;
+    private readonly resourceDiscovery;
+    private readonly i18n;
+    private discoveredResourceOptions;
     private lastCurrencyPreset;
     constructor(registry: ConfigRegistryService, normalizer: SchemaNormalizerService, factory: DynamicFormFactoryService, ctxValidators: ContextValidatorRegistryService);
+    private catalogLookupRequested;
+    private readonly resourceSchemaFieldsByPath;
+    private readonly resourceSchemaRequestIdByScope;
     ngOnInit(): void;
+    private loadCatalogResourceOptionsIfNeeded;
+    private resolveDiscoveryEndpointKey;
+    private bindResourcePathSchemaSync;
+    private seedCatalogResponseFieldsCache;
+    private resolveAndApplyResourceSchemaFields;
     private resolveCanonicalEditorProperties;
     private rebuildEditorForType;
     private setupGradientStopValidationSync;
@@ -210,7 +229,16 @@ declare class FieldMetadataEditorComponent implements OnInit {
     onControlTypeChangeEvent(event: Event): void;
     private withSharedFieldMetadataProperties;
     get isArrayEditor(): boolean;
+    private static readonly ROOT_DEPENDENT_FIELD_KEY_PROPS;
+    private static readonly OPTION_SOURCE_DEPENDENT_FIELD_KEY_PROPS;
     private buildRenderedProps;
+    private enrichResourcePathProperty;
+    private enrichDependentFieldKeyProperty;
+    private normalizeResourceCacheKey;
+    private getCachedFieldsForResource;
+    private setCachedFieldsForResource;
+    private applyAutoSuggestedDependentKeys;
+    private selectSuggestedFieldKeys;
     private cloneSnapshot;
     private cloneMetadataValue;
     private canEmitSettingsValue;