@praxisui/crud 3.0.0-beta.8 → 4.0.0-beta.0

package/fesm2022/praxisui-crud.mjs

@@ -1,15 +1,15 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, EventEmitter, DestroyRef, ViewChild, Output, Input, Component, Inject, ENVIRONMENT_INITIALIZER } from '@angular/core';
+import { Injectable, InjectionToken, inject, EventEmitter, DestroyRef, ChangeDetectorRef, ViewChild, Output, Input, Component, Inject, ENVIRONMENT_INITIALIZER } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { Router, ActivatedRoute, RouterLink } from '@angular/router';
-import { PraxisTable } from '@praxisui/table';
+import { MatSnackBar } from '@angular/material/snack-bar';
 import { firstValueFrom } from 'rxjs';
+import * as i2 from '@praxisui/core';
+import { ASYNC_CONFIG_STORAGE, GlobalConfigService, fillUndefined, createDefaultTableConfig, PraxisI18nService, ResourceDiscoveryService, ResourceActionOpenAdapterService, ResourceSurfaceOpenAdapterService, GLOBAL_SURFACE_SERVICE, ComponentKeyService, translateUnavailableWorkflowMessage, EmptyStateCardComponent, providePraxisI18nConfig, RESOURCE_DISCOVERY_I18N_CONFIG, PraxisIconDirective, GenericCrudService, ComponentMetadataRegistry } from '@praxisui/core';
+import { PraxisTable } from '@praxisui/table';
 import * as i1 from '@angular/material/dialog';
 import { MatDialogRef, MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
 export { MAT_DIALOG_DATA as DIALOG_DATA } from '@angular/material/dialog';
-import * as i2 from '@praxisui/core';
-import { ASYNC_CONFIG_STORAGE, GlobalConfigService, fillUndefined, createDefaultTableConfig, ComponentKeyService, EmptyStateCardComponent, PraxisIconDirective, GenericCrudService, ComponentMetadataRegistry } from '@praxisui/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { MatSnackBar } from '@angular/material/snack-bar';
 import * as i1$1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import * as i4 from '@angular/material/button';
@@ -290,61 +290,125 @@ function assertCrudMetadata(meta, options = {}) {
     });
 }
 
+const PRAXIS_CRUD_RUNTIME_I18N_NAMESPACE = 'praxisCrudRuntime';
+const PRAXIS_CRUD_RUNTIME_I18N_CONFIG = {
+    namespaces: {
+        [PRAXIS_CRUD_RUNTIME_I18N_NAMESPACE]: {
+            'pt-BR': {
+                'crud.emptyState.title': 'Conecte o CRUD a um recurso',
+                'crud.emptyState.description': 'Informe os metadados (resourcePath / schema) ou forneça metadata.data para habilitar a tabela e as ações.',
+                'crud.emptyState.primaryAction': 'Configurar metadados',
+                'crud.preferences.resetSuccess': 'Overrides de CRUD redefinidos',
+                'crud.actions.create': 'Adicionar',
+                'crud.actions.view': 'Ver',
+                'crud.actions.edit': 'Editar',
+                'crud.actions.delete': 'Excluir',
+            },
+            'en-US': {
+                'crud.emptyState.title': 'Connect CRUD to a resource',
+                'crud.emptyState.description': 'Provide metadata (resourcePath / schema) or metadata.data to enable the table and actions.',
+                'crud.emptyState.primaryAction': 'Configure metadata',
+                'crud.preferences.resetSuccess': 'CRUD overrides reset',
+                'crud.actions.create': 'Add',
+                'crud.actions.view': 'View',
+                'crud.actions.edit': 'Edit',
+                'crud.actions.delete': 'Delete',
+            },
+        },
+    },
+};
+function getCrudRuntimeDictionary(locale) {
+    const dictionaries = PRAXIS_CRUD_RUNTIME_I18N_CONFIG.namespaces?.[PRAXIS_CRUD_RUNTIME_I18N_NAMESPACE];
+    if (!dictionaries) {
+        return undefined;
+    }
+    const normalized = String(locale || '').trim();
+    const candidates = [
+        normalized,
+        normalized.toLowerCase(),
+        normalized.includes('-') ? normalized.split('-')[0] : '',
+        normalized.includes('_') ? normalized.split('_')[0] : '',
+        'pt-BR',
+        'pt-br',
+        'en-US',
+        'en-us',
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        const dictionary = dictionaries[candidate];
+        if (dictionary && typeof dictionary === 'object') {
+            return dictionary;
+        }
+    }
+    return undefined;
+}
+function resolveCrudRuntimeFallback(key, locale) {
+    return getCrudRuntimeDictionary(locale || 'pt-BR')?.[key];
+}
+function translateCrudRuntimeText(i18n, key, fallback, params, locale) {
+    const runtimeFallback = resolveCrudRuntimeFallback(key, locale)
+        || resolveCrudRuntimeFallback(key, locale || i18n.getLocale?.() || i18n.getFallbackLocale?.() || 'pt-BR')
+        || fallback
+        || key;
+    return i18n.t(key, params, runtimeFallback, PRAXIS_CRUD_RUNTIME_I18N_NAMESPACE);
+}
+
 class PraxisCrudComponent {
-    /** JSON inline ou chave/URL resolvida pelo MetadataResolver */
     metadata;
-    /** Identificador obrigatório do CRUD (base para tabela/formulário) */
     crudId;
-    /** Identificador opcional para instâncias múltiplas */
     componentInstanceId;
     context;
-    /** Encaminha o modo de edição de layout para a tabela interna */
     enableCustomization = false;
-    /** CTA: usado pelo Builder para abrir configuração de metadados quando vazio */
     configureRequested = new EventEmitter();
     afterOpen = new EventEmitter();
     afterClose = new EventEmitter();
     afterSave = new EventEmitter();
     afterDelete = new EventEmitter();
     error = new EventEmitter();
-    /**
-     * Emits the live PraxisTable configuration snapshot after runtime hydration or
-     * metadata refreshes. This reflects the effective table state in memory,
-     * deduplicated by structural JSON equality, and is intended for external hosts
-     * that need to mirror the table editor/runtime state.
-     */
     tableRuntimeConfigChange = new EventEmitter();
     resolvedMetadata;
-    /** Configuração efetiva da tabela com melhorias automáticas (ex.: botão Adicionar). */
     effectiveTableConfig;
-    /** Config passado ao PraxisTable — sempre definido (fallback seguro). */
     tableConfigForBinding = createDefaultTableConfig();
+    tableQueryContext = null;
+    tableFilterCriteria = {};
+    tableCrudContext;
     launcher = inject(CrudLauncherService);
     destroyRef = inject(DestroyRef);
+    cdr = inject(ChangeDetectorRef);
     table;
     storage = inject(ASYNC_CONFIG_STORAGE);
     snack = inject(MatSnackBar);
-    global = (() => { try {
-        return inject(GlobalConfigService);
-    }
-    catch {
-        return undefined;
-    } })();
+    i18n = inject(PraxisI18nService);
+    resourceDiscovery = inject(ResourceDiscoveryService);
+    actionOpenAdapter = inject(ResourceActionOpenAdapterService);
+    surfaceOpenAdapter = inject(ResourceSurfaceOpenAdapterService);
+    global = (() => {
+        try {
+            return inject(GlobalConfigService);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    surfaceService = inject(GLOBAL_SURFACE_SERVICE, { optional: true });
     componentKeys = inject(ComponentKeyService);
-    route = (() => { try {
-        return inject(ActivatedRoute);
-    }
-    catch {
-        return undefined;
-    } })();
+    route = (() => {
+        try {
+            return inject(ActivatedRoute);
+        }
+        catch {
+            return undefined;
+        }
+    })();
     warnedMissingId = false;
     lastEmittedTableRuntimeConfigJson = '';
-    /**
-     * Stable CRUD context passed to PraxisTable.
-     * Previously this was created via a getter, producing a new object each CD tick
-     * and causing excessive re-renders. Now we compute it only when metadata changes.
-     */
-    tableCrudContext;
+    lastAssignedTableConfigJson = '';
+    lastAssignedTableCrudContextJson = '';
+    lastAppliedResourceIdentity = null;
+    tableCollectionLinks = null;
+    collectionCapabilities = null;
+    collectionCapabilitiesRequestHref = null;
+    collectionCapabilitiesResolvedHref = null;
+    collectionCapabilitiesRequestSeq = 0;
     onResetPreferences() {
         try {
             const keyId = this.componentKeyId();
@@ -352,44 +416,51 @@ class PraxisCrudComponent {
                 return;
             const key = `crud-overrides:${keyId}`;
             void firstValueFrom(this.storage.clearConfig(key)).catch(() => { });
-            this.snack.open('Overrides de CRUD redefinidos', undefined, { duration: 2000 });
+            this.snack.open(this.tx('crud.preferences.resetSuccess', 'CRUD overrides reset'), undefined, {
+                duration: 2000,
+            });
         }
         catch { }
     }
     ngOnChanges(changes) {
-        if (changes['metadata']) {
-            try {
-                const parsed = typeof this.metadata === 'string'
-                    ? JSON.parse(this.metadata)
-                    : this.metadata;
-                this.resolvedMetadata = parsed;
-                // Runtime metadata must stay structurally valid, but route/formId can be
-                // completed later by launcher overrides, defaults or host policy.
-                assertCrudMetadata(this.resolvedMetadata, {
-                    allowDeferredActionBindings: true,
-                });
-                this.effectiveTableConfig = this.buildEffectiveTableConfig(this.resolvedMetadata);
-                // Evitar passar undefined para [config], o que sobrescreve o default do PraxisTable
-                this.tableConfigForBinding =
-                    this.effectiveTableConfig ||
-                        (this.resolvedMetadata.table ??
-                            createDefaultTableConfig());
-                // Build a stable table context when metadata changes
-                this.tableCrudContext = this.buildTableCrudContext(this.resolvedMetadata);
-            }
-            catch (err) {
-                this.error.emit(err);
-            }
+        if (!changes['metadata']) {
+            return;
+        }
+        try {
+            const parsed = typeof this.metadata === 'string'
+                ? JSON.parse(this.metadata)
+                : this.metadata;
+            this.resolvedMetadata = parsed;
+            assertCrudMetadata(this.resolvedMetadata, {
+                allowDeferredActionBindings: true,
+            });
+            this.tableQueryContext = this.resolveQueryContext(this.resolvedMetadata);
+            this.tableFilterCriteria = this.resolveFilterCriteria(this.resolvedMetadata);
+            this.tableCollectionLinks = null;
+            this.collectionCapabilities = null;
+            this.collectionCapabilitiesRequestHref = null;
+            this.collectionCapabilitiesResolvedHref = null;
+            this.collectionCapabilitiesRequestSeq += 1;
+            this.applyResolvedCrudState(this.resolvedMetadata);
+        }
+        catch (err) {
+            this.error.emit(err);
         }
     }
-    async onAction(action, row) {
+    async onAction(action, row, runtimeEvent) {
         try {
             document.activeElement?.blur();
-            let actionMeta = this.resolvedMetadata.actions?.find((a) => a.action === action);
-            // Fallback: if metadata.actions is missing or doesn't include the action,
-            // synthesize from table CRUD context or let overrides drive behavior.
+            const openedByDiscovery = await this.tryOpenDiscoveredCrudSurface(action, row);
+            if (openedByDiscovery) {
+                return;
+            }
+            const handledByWorkflowAction = await this.tryOpenDiscoveredWorkflowAction(action, row, runtimeEvent);
+            if (handledByWorkflowAction) {
+                return;
+            }
+            let actionMeta = this.resolvedMetadata.actions?.find((candidate) => candidate.action === action);
             if (!actionMeta) {
-                const ctxAction = this.tableCrudContext?.actions?.find((a) => a.action === action);
+                const ctxAction = this.tableCrudContext?.actions?.find((candidate) => candidate.action === action);
                 if (ctxAction) {
                     actionMeta = {
                         action: ctxAction.action,
@@ -399,7 +470,6 @@ class PraxisCrudComponent {
                     };
                 }
                 else {
-                    // Minimal stub – CrudLauncherService will merge overrides/defaults
                     actionMeta = { action };
                 }
             }
@@ -412,9 +482,7 @@ class PraxisCrudComponent {
                 this.afterClose.emit();
             };
             const { mode, ref } = await this.launcher.launch(effectiveAction, row, this.resolvedMetadata, this.componentKeyId(), {
-                onClose: () => {
-                    emitDrawerClose();
-                },
+                onClose: () => emitDrawerClose(),
                 onResult: (result) => {
                     emitDrawerClose();
                     const data = (result?.data || {});
@@ -432,35 +500,33 @@ class PraxisCrudComponent {
                 },
             });
             this.afterOpen.emit({ mode, action: effectiveAction.action });
-            if (ref) {
-                const idField = this.getIdField();
-                ref
-                    .afterClosed()
-                    .pipe(takeUntilDestroyed(this.destroyRef))
-                    .subscribe((result) => {
-                    this.afterClose.emit();
-                    if (result?.type === 'save') {
-                        const data = result.data;
-                        const id = data?.[idField];
-                        this.afterSave.emit({ id, data: result.data });
-                        this.refreshTable();
-                    }
-                    if (result?.type === 'delete') {
-                        const data = result.data;
-                        const id = data?.[idField];
-                        this.afterDelete.emit({ id });
-                        this.refreshTable();
-                    }
-                });
+            if (!ref) {
+                return;
             }
+            const idField = this.getIdField();
+            ref
+                .afterClosed()
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe((result) => {
+                this.afterClose.emit();
+                if (result?.type === 'save') {
+                    const data = result.data;
+                    const id = data?.[idField];
+                    this.afterSave.emit({ id, data: result.data });
+                    this.refreshTable();
+                }
+                if (result?.type === 'delete') {
+                    const data = result.data;
+                    const id = data?.[idField];
+                    this.afterDelete.emit({ id });
+                    this.refreshTable();
+                }
+            });
         }
         catch (err) {
             this.error.emit(err);
         }
     }
-    refreshTable() {
-        this.table.refetch();
-    }
     getCurrentTableConfigSnapshot() {
         const current = this.table?.config || this.tableConfigForBinding || this.effectiveTableConfig;
         if (!current)
@@ -483,20 +549,50 @@ class PraxisCrudComponent {
         }
         this.emitTableRuntimeConfigSnapshot();
     }
-    emitTableRuntimeConfigSnapshot() {
-        const snapshot = this.getCurrentTableConfigSnapshot();
-        if (!snapshot)
+    onCollectionLinksChange(links) {
+        this.tableCollectionLinks = links || null;
+        const capabilitiesHref = this.resolveCollectionCapabilitiesHref(links);
+        if (!capabilitiesHref) {
+            this.collectionCapabilitiesRequestSeq += 1;
+            this.collectionCapabilitiesRequestHref = null;
+            this.collectionCapabilitiesResolvedHref = null;
+            if (this.collectionCapabilities) {
+                this.collectionCapabilities = null;
+                this.applyResolvedCrudState(this.resolvedMetadata);
+                this.syncRuntimeBindings();
+            }
             return;
-        try {
-            const nextJson = JSON.stringify(snapshot);
-            if (nextJson === this.lastEmittedTableRuntimeConfigJson)
-                return;
-            this.lastEmittedTableRuntimeConfigJson = nextJson;
         }
-        catch {
-            // Fallback to emitting when serialization is not possible.
+        if (capabilitiesHref === this.collectionCapabilitiesRequestHref ||
+            (capabilitiesHref === this.collectionCapabilitiesResolvedHref && !!this.collectionCapabilities)) {
+            return;
         }
-        this.tableRuntimeConfigChange.emit(snapshot);
+        const requestSeq = ++this.collectionCapabilitiesRequestSeq;
+        this.collectionCapabilitiesRequestHref = capabilitiesHref;
+        void firstValueFrom(this.resourceDiscovery.getCapabilities(links || {}, this.buildDiscoveryOptions()))
+            .then((snapshot) => {
+            if (requestSeq !== this.collectionCapabilitiesRequestSeq) {
+                return;
+            }
+            this.collectionCapabilitiesRequestHref = null;
+            this.collectionCapabilitiesResolvedHref = capabilitiesHref;
+            this.collectionCapabilities = snapshot;
+            this.applyResolvedCrudState(this.resolvedMetadata);
+            this.syncRuntimeBindings();
+        })
+            .catch(() => {
+            if (requestSeq !== this.collectionCapabilitiesRequestSeq) {
+                return;
+            }
+            const hadCapabilities = !!this.collectionCapabilities;
+            this.collectionCapabilities = null;
+            this.collectionCapabilitiesRequestHref = null;
+            this.collectionCapabilitiesResolvedHref = null;
+            if (hadCapabilities) {
+                this.applyResolvedCrudState(this.resolvedMetadata);
+                this.syncRuntimeBindings();
+            }
+        });
     }
     resolveResourcePath(meta) {
         return (meta?.resource?.path ||
@@ -516,73 +612,462 @@ class PraxisCrudComponent {
     shouldRenderTable(meta) {
         return this.resolveResourcePath(meta).length > 0 || Array.isArray(meta?.data);
     }
-    getIdField() {
-        return this.resolvedMetadata?.resource?.idField || 'id';
+    getEmptyStateTitle() {
+        return this.tx('crud.emptyState.title', 'Connect CRUD to a resource');
+    }
+    getEmptyStateDescription() {
+        return this.tx('crud.emptyState.description', 'Provide metadata (resourcePath / schema) or metadata.data to enable the table and actions.');
+    }
+    getEmptyStatePrimaryAction() {
+        return this.tx('crud.emptyState.primaryAction', 'Configure metadata');
     }
     onConfigureRequested() {
         this.configureRequested.emit();
     }
-    /**
-     * Constrói uma configuração de tabela efetiva a partir dos metadados,
-     * adicionando automaticamente a ação de "Adicionar" na toolbar quando aplicável.
-     * - Evita duplicidade se a toolbar já tiver ação equivalente.
-     * - Garante visibilidade da toolbar quando a ação é injetada.
-     */
-    buildEffectiveTableConfig(meta) {
+    refreshTable() {
+        this.table.refetch();
+    }
+    emitTableRuntimeConfigSnapshot() {
+        const snapshot = this.getCurrentTableConfigSnapshot();
+        if (!snapshot)
+            return;
+        try {
+            const nextJson = JSON.stringify(snapshot);
+            if (nextJson === this.lastEmittedTableRuntimeConfigJson)
+                return;
+            this.lastEmittedTableRuntimeConfigJson = nextJson;
+        }
+        catch { }
+        this.tableRuntimeConfigChange.emit(snapshot);
+    }
+    applyResolvedCrudState(meta) {
+        this.effectiveTableConfig = this.buildEffectiveTableConfig(meta, this.collectionCapabilities);
+        const nextTableConfig = this.effectiveTableConfig ||
+            (meta.table ?? createDefaultTableConfig());
+        this.assignTableConfigForBinding(nextTableConfig);
+        this.assignTableCrudContext(this.buildTableCrudContext(meta, this.collectionCapabilities));
+        this.lastAppliedResourceIdentity = this.resolveCrudResourceIdentity(meta);
+    }
+    assignTableConfigForBinding(next) {
+        const nextJson = this.safeSerialize(next);
+        if (nextJson !== null && nextJson === this.lastAssignedTableConfigJson) {
+            return;
+        }
+        this.lastAssignedTableConfigJson = nextJson ?? '';
+        this.tableConfigForBinding = next;
+    }
+    assignTableCrudContext(next) {
+        const nextJson = this.safeSerialize(next);
+        if (nextJson !== null && nextJson === this.lastAssignedTableCrudContextJson) {
+            return;
+        }
+        this.lastAssignedTableCrudContextJson = nextJson ?? '';
+        this.tableCrudContext = next;
+    }
+    safeSerialize(value) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    syncRuntimeBindings() {
+        try {
+            this.cdr.detectChanges();
+        }
+        catch {
+            try {
+                this.cdr.markForCheck();
+            }
+            catch { }
+        }
+    }
+    resolveQueryContext(meta) {
+        return this.isRecord(meta?.queryContext) ? meta.queryContext : null;
+    }
+    resolveFilterCriteria(meta) {
+        return this.isRecord(meta?.filterCriteria) ? { ...meta.filterCriteria } : {};
+    }
+    async tryOpenDiscoveredCrudSurface(action, row) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        if (!this.isDiscoveryManagedCrudAction(normalizedAction) || !this.surfaceService) {
+            return false;
+        }
+        const catalog = await this.resolveDiscoveredSurfaceCatalog(normalizedAction, row);
+        const surface = this.selectSurfaceForCrudAction(normalizedAction, catalog?.surfaces || []);
+        const resourcePath = String(catalog?.resourcePath || this.resolveResourcePath(this.resolvedMetadata) || '').trim();
+        if (!catalog || !surface || !resourcePath) {
+            return false;
+        }
+        let payload;
+        try {
+            payload = this.surfaceOpenAdapter.toPayload(surface, {
+                resourcePath,
+                resourceId: this.resolveRowResourceId(row),
+                endpointKey: this.resolvedMetadata?.resource?.endpointKey,
+                apiUrlEntry: this.resolveDiscoveryApiEntry(),
+                group: catalog.group ?? null,
+            });
+        }
+        catch {
+            return false;
+        }
+        let openPromise;
+        try {
+            openPromise = Promise.resolve(this.surfaceService.open(payload, {
+                sourceId: this.componentKeyId() || undefined,
+                payload: { action: normalizedAction, row: row ?? null },
+                meta: {
+                    crudId: this.crudId,
+                    resourcePath,
+                    surfaceId: surface.id,
+                    operationId: surface.operationId,
+                },
+                runtime: {
+                    row: row ?? null,
+                    item: row ?? null,
+                    state: {
+                        action: normalizedAction,
+                        resourcePath,
+                    },
+                },
+            }));
+        }
+        catch {
+            return false;
+        }
+        this.afterOpen.emit({
+            mode: this.mapSurfacePresentationToCrudMode(payload?.presentation),
+            action,
+        });
+        void openPromise
+            .then((result) => this.handleDiscoveredSurfaceResult(result))
+            .catch((err) => this.error.emit(err));
+        return true;
+    }
+    async resolveDiscoveredSurfaceCatalog(action, row) {
+        try {
+            if (action === 'create') {
+                if (!this.tableCollectionLinks) {
+                    return null;
+                }
+                return await firstValueFrom(this.resourceDiscovery.getSurfaces(this.tableCollectionLinks, this.buildDiscoveryOptions()));
+            }
+            const rowLinks = row?._links;
+            if (!rowLinks) {
+                return null;
+            }
+            return await firstValueFrom(this.resourceDiscovery.getSurfaces(rowLinks, this.buildDiscoveryOptions()));
+        }
+        catch {
+            return null;
+        }
+    }
+    async tryOpenDiscoveredWorkflowAction(action, row, runtimeEvent) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        if (!normalizedAction || this.isDiscoveryManagedCrudAction(normalizedAction) || !this.surfaceService) {
+            return false;
+        }
+        const providedAction = this.resolveProvidedWorkflowAction(normalizedAction, runtimeEvent?.actionConfig);
+        const catalog = providedAction ? null : await this.resolveDiscoveredActionCatalog(row);
+        const discoveredAction = providedAction || this.selectDiscoveredWorkflowAction(normalizedAction, catalog?.actions || []);
+        const resourcePath = String(catalog?.resourcePath || this.resolveResourcePath(this.resolvedMetadata) || '').trim();
+        if (!discoveredAction || !resourcePath) {
+            return false;
+        }
+        if (discoveredAction.availability?.allowed === false) {
+            this.snack.open(translateUnavailableWorkflowMessage(this.i18n, discoveredAction.availability), undefined, { duration: 2500 });
+            return true;
+        }
+        let payload;
+        try {
+            payload = this.actionOpenAdapter.toPayload(discoveredAction, {
+                resourcePath,
+                resourceId: this.resolveRowResourceId(row),
+                endpointKey: this.resolvedMetadata?.resource?.endpointKey,
+                apiUrlEntry: this.resolveDiscoveryApiEntry(),
+                group: catalog?.group ?? null,
+            });
+        }
+        catch {
+            return false;
+        }
+        let openPromise;
+        try {
+            openPromise = Promise.resolve(this.surfaceService.open(payload, {
+                sourceId: this.componentKeyId() || undefined,
+                payload: { action: normalizedAction, row: row ?? null },
+                meta: {
+                    crudId: this.crudId,
+                    resourcePath,
+                    actionId: discoveredAction.id,
+                    operationId: discoveredAction.operationId,
+                },
+                runtime: {
+                    row: row ?? null,
+                    item: row ?? null,
+                    state: {
+                        action: normalizedAction,
+                        resourcePath,
+                    },
+                },
+            }));
+        }
+        catch {
+            return false;
+        }
+        this.afterOpen.emit({
+            mode: this.mapSurfacePresentationToCrudMode(payload?.presentation),
+            action,
+        });
+        void openPromise
+            .then((result) => this.handleDiscoveredSurfaceResult(result))
+            .catch((err) => this.error.emit(err));
+        return true;
+    }
+    async resolveDiscoveredActionCatalog(row) {
+        try {
+            if (row) {
+                const rowLinks = row?._links;
+                if (!rowLinks) {
+                    return null;
+                }
+                return await firstValueFrom(this.resourceDiscovery.getActions(rowLinks, this.buildDiscoveryOptions()));
+            }
+            if (!this.tableCollectionLinks) {
+                return null;
+            }
+            return await firstValueFrom(this.resourceDiscovery.getActions(this.tableCollectionLinks, this.buildDiscoveryOptions()));
+        }
+        catch {
+            return null;
+        }
+    }
+    selectDiscoveredWorkflowAction(action, actions) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        return (actions
+            .slice()
+            .sort((left, right) => (left.order ?? 0) - (right.order ?? 0))
+            .find((candidate) => String(candidate.id || '').trim().toLowerCase() === normalizedAction) ||
+            null);
+    }
+    resolveProvidedWorkflowAction(action, candidate) {
+        if (!candidate || typeof candidate !== 'object') {
+            return null;
+        }
+        const normalizedId = String(candidate.id || '').trim().toLowerCase();
+        if (!normalizedId || normalizedId !== action) {
+            return null;
+        }
+        if (!candidate.operationId || !candidate.path || !candidate.method) {
+            return null;
+        }
+        return candidate;
+    }
+    selectSurfaceForCrudAction(action, surfaces) {
+        const candidates = surfaces
+            .filter((surface) => surface.availability?.allowed !== false)
+            .sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+        const preferredIds = this.getPreferredSurfaceIdsForCrudAction(action);
+        const preferred = candidates.find((surface) => preferredIds.includes(String(surface.id || '').trim().toLowerCase()));
+        if (preferred) {
+            return preferred;
+        }
+        if (action === 'create') {
+            return (candidates.find((surface) => surface.scope === 'COLLECTION' &&
+                this.isWritableCrudSurface(surface) &&
+                String(surface.method || '').toUpperCase() === 'POST') ||
+                candidates.find((surface) => surface.scope === 'COLLECTION' && this.isWritableCrudSurface(surface)) ||
+                null);
+        }
+        if (action === 'view') {
+            return (candidates.find((surface) => surface.scope === 'ITEM' &&
+                this.isReadableCrudSurface(surface) &&
+                String(surface.method || '').toUpperCase() === 'GET') ||
+                candidates.find((surface) => surface.scope === 'ITEM' && this.isReadableCrudSurface(surface)) ||
+                null);
+        }
+        if (action === 'edit') {
+            return (candidates.find((surface) => surface.scope === 'ITEM' &&
+                this.isWritableCrudSurface(surface) &&
+                ['PUT', 'PATCH'].includes(String(surface.method || '').toUpperCase())) ||
+                candidates.find((surface) => surface.scope === 'ITEM' && this.isWritableCrudSurface(surface)) ||
+                null);
+        }
+        return null;
+    }
+    getPreferredSurfaceIdsForCrudAction(action) {
+        switch (action) {
+            case 'create':
+                return ['create'];
+            case 'view':
+                return ['detail', 'view'];
+            case 'edit':
+                return ['edit', 'update'];
+            default:
+                return [];
+        }
+    }
+    isDiscoveryManagedCrudAction(action) {
+        return action === 'create' || action === 'view' || action === 'edit';
+    }
+    isWritableCrudSurface(surface) {
+        return surface.kind === 'FORM' || surface.kind === 'PARTIAL_FORM';
+    }
+    isReadableCrudSurface(surface) {
+        return surface.kind === 'VIEW' || surface.kind === 'READ_PROJECTION';
+    }
+    resolveRowResourceId(row) {
+        if (!row) {
+            return null;
+        }
+        const value = row[this.getIdField()];
+        return typeof value === 'string' || typeof value === 'number' ? value : null;
+    }
+    mapSurfacePresentationToCrudMode(presentation) {
+        return presentation === 'modal' ? 'modal' : 'drawer';
+    }
+    handleDiscoveredSurfaceResult(result) {
+        this.afterClose.emit();
+        const data = (result?.data || {});
+        const idField = this.getIdField();
+        if (result?.type === 'save') {
+            const id = data?.[idField];
+            this.afterSave.emit({ id, data });
+            this.refreshTable();
+        }
+        if (result?.type === 'delete') {
+            const id = data?.[idField];
+            this.afterDelete.emit({ id });
+            this.refreshTable();
+        }
+    }
+    buildEffectiveTableConfig(meta, capabilities) {
         const base = meta.table;
-        // Clonar base ou criar default para permitir injeção de melhorias
+        const current = this.getCurrentTableConfigSnapshot();
+        const nextResourceIdentity = this.resolveCrudResourceIdentity(meta);
         const cfg = base
             ? JSON.parse(JSON.stringify(base))
             : createDefaultTableConfig();
         let changed = false;
+        if (nextResourceIdentity !== null &&
+            nextResourceIdentity === this.lastAppliedResourceIdentity &&
+            (cfg.columns?.length ?? 0) === 0 &&
+            (current?.columns?.length ?? 0) > 0) {
+            cfg.columns = JSON.parse(JSON.stringify(current.columns));
+            changed = true;
+        }
+        if (Array.isArray(meta?.data) && this.resolveResourcePath(meta).length === 0) {
+            const behavior = cfg.behavior || {};
+            const localDataMode = behavior.localDataMode || {};
+            if (localDataMode.enabled !== true) {
+                cfg.behavior = {
+                    ...behavior,
+                    localDataMode: {
+                        ...localDataMode,
+                        enabled: true,
+                    },
+                };
+                changed = true;
+            }
+        }
         const ensureToolbar = () => {
             if (!cfg.toolbar) {
                 cfg.toolbar = { visible: true, position: 'top' };
             }
             return cfg.toolbar;
         };
-        // 1) Toolbar: injetar ação "Adicionar" se metadata declara create/add e toolbar não tiver
-        const hasToolbarAdd = (cfg.toolbar?.actions || []).some((a) => this.isAddLike(a));
-        const addAction = (meta.actions || []).find((a) => this.isAddLike(a));
+        const hasToolbarAdd = (cfg.toolbar?.actions || []).some((action) => this.isAddLike(action));
+        const addAction = this.resolveCreateToolbarAction(meta, capabilities);
         if (addAction) {
             if (hasToolbarAdd) {
-                const tb = ensureToolbar();
-                tb.visible = true; // garantir visibilidade
+                const toolbar = ensureToolbar();
+                toolbar.visible = true;
             }
             else {
-                const tb = ensureToolbar();
-                tb.visible = true;
-                if (!tb.actions)
-                    tb.actions = [];
-                const injected = {
+                const toolbar = ensureToolbar();
+                toolbar.visible = true;
+                if (!toolbar.actions) {
+                    toolbar.actions = [];
+                }
+                toolbar.actions.push({
                     id: addAction.id || 'add',
-                    label: addAction.label || 'Adicionar',
+                    label: addAction.label || this.getCrudActionLabel('create'),
                     icon: addAction.icon || 'add',
                     type: 'button',
                     color: 'primary',
                     position: 'end',
                     action: addAction.action || 'add',
-                };
-                tb.actions.push(injected);
+                });
             }
             changed = true;
         }
-        // 2) Row actions automáticas (apenas quando host não definiu explicitamente)
+        const discoveredToolbarActions = this.resolveCollectionWorkflowToolbarActions(capabilities);
+        if (discoveredToolbarActions.length) {
+            const toolbar = ensureToolbar();
+            toolbar.visible = true;
+            if (!toolbar.actions) {
+                toolbar.actions = [];
+            }
+            for (const action of discoveredToolbarActions) {
+                const actionId = String(action.action || action.id || '')
+                    .trim()
+                    .toLowerCase();
+                const alreadyExists = toolbar.actions.some((candidate) => String(candidate?.action || candidate?.id || candidate?.code || candidate?.key || '')
+                    .trim()
+                    .toLowerCase() === actionId);
+                if (!alreadyExists) {
+                    toolbar.actions.push(action);
+                    changed = true;
+                }
+            }
+        }
         const hostDefinedRow = !!(base && base.actions && base.actions.row);
-        const crudDefaults = this.global.get('crud.defaults') || {};
-        const autoRow = crudDefaults.autoRowActions !== false; // default true
+        const crudDefaults = this.global?.get('crud.defaults') || {};
+        const autoRow = crudDefaults.autoRowActions !== false;
         if (!hostDefinedRow && autoRow) {
-            const acts = (meta.actions || []);
-            const hasView = acts.some((a) => String(a.action).toLowerCase() === 'view');
-            const hasEdit = acts.some((a) => String(a.action).toLowerCase() === 'edit');
-            const includeDelete = !!crudDefaults.includeDeleteInRow && acts.some((a) => String(a.action).toLowerCase() === 'delete');
+            const acts = this.resolveContextCrudActions(meta, capabilities);
+            const hasView = capabilities
+                ? this.supportsViewCapability(capabilities)
+                : acts.some((action) => String(action.action).toLowerCase() === 'view');
+            const hasEdit = capabilities
+                ? this.supportsEditCapability(capabilities)
+                : acts.some((action) => String(action.action).toLowerCase() === 'edit');
+            const includeDelete = capabilities
+                ? !!crudDefaults.includeDeleteInRow &&
+                    this.supportsDeleteCapability(capabilities) &&
+                    acts.some((action) => String(action.action).toLowerCase() === 'delete')
+                : !!crudDefaults.includeDeleteInRow &&
+                    acts.some((action) => String(action.action).toLowerCase() === 'delete');
             const rowActions = [];
-            if (hasView)
-                rowActions.push({ id: 'view', label: 'Ver', icon: 'visibility', action: 'view', tooltip: 'Ver' });
-            if (hasEdit)
-                rowActions.push({ id: 'edit', label: 'Editar', icon: 'edit', action: 'edit', tooltip: 'Editar' });
-            if (includeDelete)
-                rowActions.push({ id: 'delete', label: 'Excluir', icon: 'delete', action: 'delete', tooltip: 'Excluir' });
+            if (hasView) {
+                rowActions.push({
+                    id: 'view',
+                    label: this.getCrudActionLabel('view'),
+                    icon: 'visibility',
+                    action: 'view',
+                    tooltip: this.getCrudActionLabel('view'),
+                });
+            }
+            if (hasEdit) {
+                rowActions.push({
+                    id: 'edit',
+                    label: this.getCrudActionLabel('edit'),
+                    icon: 'edit',
+                    action: 'edit',
+                    tooltip: this.getCrudActionLabel('edit'),
+                });
+            }
+            if (includeDelete) {
+                rowActions.push({
+                    id: 'delete',
+                    label: this.getCrudActionLabel('delete'),
+                    icon: 'delete',
+                    action: 'delete',
+                    tooltip: this.getCrudActionLabel('delete'),
+                });
+            }
             if (rowActions.length) {
                 cfg.actions = cfg.actions || {};
                 cfg.actions.row = {
@@ -597,53 +1082,197 @@ class PraxisCrudComponent {
                 changed = true;
             }
         }
-        // Se nada foi alterado e havia base, não retornar para preservar semântica anterior
         if (!changed) {
             return base ? undefined : cfg;
         }
         return cfg;
     }
-    /** Heurística leve para identificar ações do tipo "adicionar/criar" */
-    isAddLike(a) {
-        if (!a)
+    isAddLike(action) {
+        if (!action)
             return false;
-        const normalize = (s) => String(s || '').trim().toLowerCase();
-        const id = normalize(a.action || a.id || a.code || a.key || a.name || a.type);
-        const icon = normalize(a.icon);
-        const label = normalize(a.label);
+        const normalize = (value) => String(value || '').trim().toLowerCase();
+        const id = normalize(action.action || action.id || action.code || action.key || action.name || action.type);
+        const icon = normalize(action.icon);
+        const label = normalize(action.label);
         const addIds = new Set(['add', 'create', 'novo', 'new', 'incluir', 'inserir']);
         if (addIds.has(id))
             return true;
         if (icon === 'add' || icon === 'add_circle' || icon === 'add_box')
             return true;
-        if (label === 'adicionar' || label === 'novo' || label === 'criar' || label === 'incluir')
+        if (label === 'adicionar' || label === 'novo' || label === 'criar' || label === 'incluir') {
             return true;
+        }
         return false;
     }
-    /** Builds a stable CRUD context object for PraxisTable based on metadata. */
-    buildTableCrudContext(meta) {
+    buildTableCrudContext(meta, capabilities) {
         if (!meta)
             return undefined;
-        // Provide a minimal default action set when metadata.actions is empty,
-        // so the editor can expose per-action overrides entirely via UI.
-        const baseActions = meta.actions && meta.actions.length
-            ? meta.actions
-            : [{ action: 'create' }, { action: 'view' }, { action: 'edit' }];
+        const baseActions = this.resolveContextCrudActions(meta, capabilities);
         return {
             tableId: this.crudId || 'default',
             componentKeyId: this.componentKeyId() || undefined,
             resourcePath: this.resolveResourcePath(meta) || undefined,
+            endpointKey: meta.resource?.endpointKey,
             defaults: meta.defaults,
-            actions: baseActions.map((a) => ({
-                action: a.action,
-                label: a.label,
-                formId: a.formId,
-                route: a.route,
-                openMode: a.openMode,
+            actions: baseActions.map((action) => ({
+                action: action.action,
+                label: action.label,
+                formId: action.formId,
+                route: action.route,
+                openMode: action.openMode,
             })),
             idField: meta.resource?.idField || 'id',
         };
     }
+    resolveCreateToolbarAction(meta, capabilities) {
+        if (capabilities && !this.supportsCreateCapability(capabilities)) {
+            return null;
+        }
+        const declared = (meta.actions || []).find((action) => this.isAddLike(action));
+        if (declared) {
+            return declared;
+        }
+        return capabilities ? { action: 'create', label: this.getCrudActionLabel('create') } : null;
+    }
+    resolveContextCrudActions(meta, capabilities) {
+        const declaredActions = (meta.actions || []).filter(Boolean);
+        if (!capabilities) {
+            return declaredActions.length
+                ? declaredActions
+                : [
+                    { action: 'create', label: this.getCrudActionLabel('create') },
+                    { action: 'view', label: this.getCrudActionLabel('view') },
+                    { action: 'edit', label: this.getCrudActionLabel('edit') },
+                ];
+        }
+        const actionMap = new Map(declaredActions.map((action) => [String(action.action || '').trim().toLowerCase(), action]));
+        const runtimeActions = [];
+        if (this.supportsCreateCapability(capabilities)) {
+            runtimeActions.push(actionMap.get('create') || {
+                action: 'create',
+                label: this.getCrudActionLabel('create'),
+            });
+        }
+        if (this.supportsViewCapability(capabilities)) {
+            runtimeActions.push(actionMap.get('view') || {
+                action: 'view',
+                label: this.getCrudActionLabel('view'),
+            });
+        }
+        if (this.supportsEditCapability(capabilities)) {
+            runtimeActions.push(actionMap.get('edit') || {
+                action: 'edit',
+                label: this.getCrudActionLabel('edit'),
+            });
+        }
+        if (this.supportsDeleteCapability(capabilities) && actionMap.has('delete')) {
+            runtimeActions.push(actionMap.get('delete'));
+        }
+        for (const action of this.resolveCollectionWorkflowCrudActions(capabilities)) {
+            const normalizedAction = String(action.action || '').trim().toLowerCase();
+            if (!normalizedAction ||
+                runtimeActions.some((candidate) => String(candidate.action || '').trim().toLowerCase() === normalizedAction)) {
+                continue;
+            }
+            runtimeActions.push(action);
+        }
+        for (const action of declaredActions) {
+            const normalizedAction = String(action.action || '').trim().toLowerCase();
+            if (normalizedAction === 'create' ||
+                normalizedAction === 'view' ||
+                normalizedAction === 'edit' ||
+                normalizedAction === 'delete') {
+                continue;
+            }
+            runtimeActions.push(action);
+        }
+        return runtimeActions;
+    }
+    resolveCollectionWorkflowCrudActions(capabilities) {
+        if (!capabilities) {
+            return [];
+        }
+        return (capabilities.actions || [])
+            .filter((action) => action.scope === 'COLLECTION')
+            .sort((left, right) => (left.order ?? 0) - (right.order ?? 0))
+            .map((action) => ({
+            action: action.id,
+            label: action.title,
+        }));
+    }
+    resolveCollectionWorkflowToolbarActions(capabilities) {
+        if (!capabilities) {
+            return [];
+        }
+        return (capabilities.actions || [])
+            .filter((action) => action.scope === 'COLLECTION')
+            .sort((left, right) => (left.order ?? 0) - (right.order ?? 0))
+            .map((action) => ({
+            id: action.id,
+            label: action.title || action.id,
+            type: 'button',
+            appearance: 'outlined',
+            position: 'end',
+            action: action.id,
+            disabled: action.availability?.allowed === false,
+            tooltip: action.description ||
+                (action.availability?.allowed === false
+                    ? translateUnavailableWorkflowMessage(this.i18n, action.availability)
+                    : undefined),
+        }));
+    }
+    supportsCreateCapability(snapshot) {
+        return (this.hasCanonicalOperation(snapshot, 'create') ||
+            snapshot.surfaces.some((surface) => surface.scope === 'COLLECTION' &&
+                this.isWritableCrudSurface(surface) &&
+                surface.availability?.allowed !== false));
+    }
+    supportsViewCapability(snapshot) {
+        return this.hasCanonicalOperation(snapshot, 'byId');
+    }
+    supportsEditCapability(snapshot) {
+        return this.hasCanonicalOperation(snapshot, 'update');
+    }
+    supportsDeleteCapability(snapshot) {
+        return this.hasCanonicalOperation(snapshot, 'delete');
+    }
+    hasCanonicalOperation(snapshot, operation) {
+        return snapshot.canonicalOperations?.[operation] === true;
+    }
+    resolveCollectionCapabilitiesHref(links) {
+        try {
+            return this.resourceDiscovery.resolveLinkHref(links || undefined, 'capabilities', this.buildDiscoveryOptions());
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveCrudResourceIdentity(meta) {
+        const resourcePath = meta ? this.resolveResourcePath(meta) : '';
+        if (!resourcePath) {
+            return null;
+        }
+        const endpointKey = String(meta?.resource?.endpointKey || '').trim().toLowerCase();
+        return `${resourcePath.toLowerCase()}|${endpointKey}`;
+    }
+    buildDiscoveryOptions() {
+        const endpointKey = this.resolvedMetadata?.resource?.endpointKey;
+        return endpointKey ? { endpointKey: endpointKey } : undefined;
+    }
+    resolveDiscoveryApiEntry() {
+        try {
+            return this.resourceDiscovery.resolveApiEntry(this.buildDiscoveryOptions());
+        }
+        catch {
+            return null;
+        }
+    }
+    isRecord(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+    getIdField() {
+        return this.resolvedMetadata?.resource?.idField || 'id';
+    }
     componentKeyId() {
         const key = this.componentKeys.buildComponentId({
             componentType: 'praxis-crud',
@@ -663,18 +1292,46 @@ class PraxisCrudComponent {
         this.warnedMissingId = true;
         console.warn('[PraxisCrud] crudId is required for config persistence.');
     }
+    getCrudActionLabel(action) {
+        switch (action) {
+            case 'create':
+                return this.tx('crud.actions.create', 'Add');
+            case 'view':
+                return this.tx('crud.actions.view', 'View');
+            case 'edit':
+                return this.tx('crud.actions.edit', 'Edit');
+            case 'delete':
+                return this.tx('crud.actions.delete', 'Delete');
+            default:
+                return action;
+        }
+    }
+    tx(key, fallback) {
+        try {
+            return translateCrudRuntimeText(this.i18n, key, fallback);
+        }
+        catch {
+            return fallback;
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCrudComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: PraxisCrudComponent, isStandalone: true, selector: "praxis-crud", inputs: { metadata: "metadata", crudId: "crudId", componentInstanceId: "componentInstanceId", context: "context", enableCustomization: "enableCustomization" }, outputs: { configureRequested: "configureRequested", afterOpen: "afterOpen", afterClose: "afterClose", afterSave: "afterSave", afterDelete: "afterDelete", error: "error", tableRuntimeConfigChange: "tableRuntimeConfigChange" }, viewQueries: [{ propertyName: "table", first: true, predicate: PraxisTable, descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: PraxisCrudComponent, isStandalone: true, selector: "praxis-crud", inputs: { metadata: "metadata", crudId: "crudId", componentInstanceId: "componentInstanceId", context: "context", enableCustomization: "enableCustomization" }, outputs: { configureRequested: "configureRequested", afterOpen: "afterOpen", afterClose: "afterClose", afterSave: "afterSave", afterDelete: "afterDelete", error: "error", tableRuntimeConfigChange: "tableRuntimeConfigChange" }, providers: [
+            providePraxisI18nConfig(RESOURCE_DISCOVERY_I18N_CONFIG),
+            providePraxisI18nConfig(PRAXIS_CRUD_RUNTIME_I18N_CONFIG),
+        ], viewQueries: [{ propertyName: "table", first: true, predicate: PraxisTable, descendants: true }], usesOnChanges: true, ngImport: i0, template: `
     @if (shouldRenderTable(resolvedMetadata)) {
       <praxis-table
         [config]="tableConfigForBinding"
         [resourcePath]="resolveResourcePath(resolvedMetadata)"
         [data]="resolveTableData(resolvedMetadata)"
+        [queryContext]="tableQueryContext"
+        [filterCriteria]="tableFilterCriteria"
         [tableId]="crudId || 'default'"
         [crudContext]="tableCrudContext"
         [enableCustomization]="enableCustomization"
-        (rowAction)="onAction($event.action, $event.row)"
+        (rowAction)="onAction($event.action, $event.row, $event)"
         (toolbarAction)="onAction($event.action)"
+        (collectionLinksChange)="onCollectionLinksChange($event)"
         (reset)="onResetPreferences()"
         (metadataChange)="onTableMetadataChange()"
         (loadingStateChange)="onTableLoadingStateChange($event)"
@@ -683,31 +1340,33 @@ class PraxisCrudComponent {
       @if (enableCustomization) {
         <praxis-empty-state-card
           icon="table_rows"
-          [title]="'Conecte o CRUD a um recurso'"
-          [description]="'Informe os metadados (resourcePath / schema) ou forneça metadata.data para habilitar a tabela e ações.'"
-          [primaryAction]="{ label: 'Configurar metadados', icon: 'bolt', action: onConfigureRequested.bind(this) }"
+          [title]="getEmptyStateTitle()"
+          [description]="getEmptyStateDescription()"
+          [primaryAction]="{ label: getEmptyStatePrimaryAction(), icon: 'bolt', action: onConfigureRequested.bind(this) }"
         />
       }
     }
-  `, isInline: true, dependencies: [{ kind: "component", type: PraxisTable, selector: "praxis-table", inputs: ["config", "resourcePath", "data", "tableId", "componentInstanceId", "title", "subtitle", "icon", "autoDelete", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "crudContext", "dslFunctionRegistry", "filterCriteria", "queryContext", "enableCustomization", "dense"], outputs: ["rowClick", "rowDoubleClick", "rowExpansionChange", "rowAction", "toolbarAction", "bulkAction", "columnReorder", "columnReorderAttempt", "beforeDelete", "afterDelete", "deleteError", "beforeBulkDelete", "afterBulkDelete", "bulkDeleteError", "schemaStatusChange", "metadataChange", "loadingStateChange"] }, { kind: "component", type: EmptyStateCardComponent, selector: "praxis-empty-state-card", inputs: ["icon", "title", "description", "primaryAction", "secondaryActions", "inline", "tone"] }] });
+  `, isInline: true, styles: [":host{display:block;width:100%;min-width:0;max-width:100%}\n"], dependencies: [{ kind: "component", type: PraxisTable, selector: "praxis-table", inputs: ["config", "resourcePath", "data", "tableId", "componentInstanceId", "title", "subtitle", "icon", "autoDelete", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "crudContext", "dslFunctionRegistry", "filterCriteria", "queryContext", "enableCustomization", "dense"], outputs: ["rowClick", "rowDoubleClick", "rowExpansionChange", "rowAction", "toolbarAction", "bulkAction", "columnReorder", "columnReorderAttempt", "beforeDelete", "afterDelete", "deleteError", "beforeBulkDelete", "afterBulkDelete", "bulkDeleteError", "schemaStatusChange", "metadataChange", "loadingStateChange", "collectionLinksChange"] }, { kind: "component", type: EmptyStateCardComponent, selector: "praxis-empty-state-card", inputs: ["icon", "title", "description", "primaryAction", "secondaryActions", "inline", "tone"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisCrudComponent, decorators: [{
             type: Component,
-            args: [{
-                    selector: 'praxis-crud',
-                    standalone: true,
-                    imports: [PraxisTable, EmptyStateCardComponent],
-                    template: `
+            args: [{ selector: 'praxis-crud', standalone: true, imports: [PraxisTable, EmptyStateCardComponent], providers: [
+                        providePraxisI18nConfig(RESOURCE_DISCOVERY_I18N_CONFIG),
+                        providePraxisI18nConfig(PRAXIS_CRUD_RUNTIME_I18N_CONFIG),
+                    ], template: `
     @if (shouldRenderTable(resolvedMetadata)) {
       <praxis-table
         [config]="tableConfigForBinding"
         [resourcePath]="resolveResourcePath(resolvedMetadata)"
         [data]="resolveTableData(resolvedMetadata)"
+        [queryContext]="tableQueryContext"
+        [filterCriteria]="tableFilterCriteria"
         [tableId]="crudId || 'default'"
         [crudContext]="tableCrudContext"
         [enableCustomization]="enableCustomization"
-        (rowAction)="onAction($event.action, $event.row)"
+        (rowAction)="onAction($event.action, $event.row, $event)"
         (toolbarAction)="onAction($event.action)"
+        (collectionLinksChange)="onCollectionLinksChange($event)"
         (reset)="onResetPreferences()"
         (metadataChange)="onTableMetadataChange()"
         (loadingStateChange)="onTableLoadingStateChange($event)"
@@ -716,14 +1375,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
       @if (enableCustomization) {
         <praxis-empty-state-card
           icon="table_rows"
-          [title]="'Conecte o CRUD a um recurso'"
-          [description]="'Informe os metadados (resourcePath / schema) ou forneça metadata.data para habilitar a tabela e ações.'"
-          [primaryAction]="{ label: 'Configurar metadados', icon: 'bolt', action: onConfigureRequested.bind(this) }"
+          [title]="getEmptyStateTitle()"
+          [description]="getEmptyStateDescription()"
+          [primaryAction]="{ label: getEmptyStatePrimaryAction(), icon: 'bolt', action: onConfigureRequested.bind(this) }"
         />
       }
     }
-  `,
-                }]
+  `, styles: [":host{display:block;width:100%;min-width:0;max-width:100%}\n"] }]
         }], propDecorators: { metadata: [{
                 type: Input,
                 args: [{ required: true }]
@@ -771,6 +1429,11 @@ class DynamicFormDialogHostComponent {
     destroyRef = inject(DestroyRef);
     resourcePath;
     resourceId;
+    schemaUrl;
+    submitUrl;
+    submitMethod;
+    apiEndpointKey;
+    apiUrlEntry;
     mode = 'create';
     backConfig;
     idField = 'id';
@@ -815,6 +1478,14 @@ class DynamicFormDialogHostComponent {
         }
         this.idField = this.data.metadata?.resource?.idField ?? 'id';
         this.resourceId = this.data.inputs?.[this.idField];
+        this.schemaUrl = this.data.inputs?.['schemaUrl'] ?? null;
+        this.submitUrl = this.data.inputs?.['submitUrl'] ?? null;
+        this.submitMethod = this.data.inputs?.['submitMethod'] ?? null;
+        this.apiEndpointKey =
+            this.data.inputs?.['apiEndpointKey'] ??
+                this.data.metadata?.resource?.endpointKey ??
+                null;
+        this.apiUrlEntry = this.data.inputs?.['apiUrlEntry'] ?? null;
         const act = this.data.action?.action;
         this.mode = act === 'edit' ? 'edit' : act === 'view' ? 'view' : 'create';
         // Back config: defaults from metadata/action, overridden by saved per-form config
@@ -1004,13 +1675,18 @@ class DynamicFormDialogHostComponent {
         [resourcePath]="resourcePath"
         [resourceId]="resourceId"
         [mode]="mode"
+        [schemaUrl]="schemaUrl"
+        [submitUrl]="submitUrl"
+        [submitMethod]="submitMethod"
+        [apiEndpointKey]="apiEndpointKey"
+        [apiUrlEntry]="apiUrlEntry"
         [presentationModeGlobal]="mode === 'view' ? true : null"
         [backConfig]="backConfig"
         (formSubmit)="onSave($event)"
         (formCancel)="onCancel()"
       ></praxis-dynamic-form>
     </mat-dialog-content>
-  `, isInline: true, styles: [":host{--dlg-header-h: 56px;--dlg-footer-h: 56px;--dlg-pad: 16px;display:flex;flex-direction:column;height:100%;overflow:hidden}:host([data-density=\"compact\"]){--dlg-header-h: 44px;--dlg-footer-h: 44px;--dlg-pad: 12px}.dialog-header{position:sticky;top:0;z-index:1;display:flex;align-items:center;gap:var(--dlg-pad);padding:0 var(--dlg-pad);height:var(--dlg-header-h);margin:0;background:var(--md-sys-color-surface-container-high);border-bottom:1px solid var(--md-sys-color-outline-variant);color:var(--md-sys-color-on-surface)}.dialog-title{margin:0;font:inherit;font-weight:600;color:var(--md-sys-color-on-surface)}.spacer{flex:1}.dialog-content{overflow:auto;padding:var(--dlg-pad);max-height:calc(100svh - var(--dlg-header-h) - 32px)}.dialog-header button.mat-icon-button{color:var(--md-sys-color-on-surface-variant)}.dialog-header button.mat-icon-button:hover{color:var(--md-sys-color-primary);background:var(--md-sys-color-primary-container)}.dialog-footer{position:sticky;bottom:0;z-index:1;padding:var(--dlg-pad)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: PraxisDynamicForm, selector: "praxis-dynamic-form", inputs: ["resourcePath", "resourceId", "editorialContext", "mode", "config", "schemaSource", "enableCustomization", "formId", "componentInstanceId", "layout", "backConfig", "hooks", "removeEmptyContainersOnSave", "reactiveValidation", "reactiveValidationDebounceMs", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "readonlyModeGlobal", "disabledModeGlobal", "presentationModeGlobal", "visibleGlobal", "customEndpoints"], outputs: ["formSubmit", "formCancel", "formReset", "configChange", "formReady", "valueChange", "syncCompleted", "initializationError", "loadingStateChange", "enableCustomizationChange", "customAction", "actionConfirmation", "schemaStatusChange", "fieldRenderError", "widgetEvent"] }] });
+  `, isInline: true, styles: [":host{--dlg-header-h: 56px;--dlg-footer-h: 56px;--dlg-pad: 16px;display:flex;flex-direction:column;height:100%;overflow:hidden}:host([data-density=\"compact\"]){--dlg-header-h: 44px;--dlg-footer-h: 44px;--dlg-pad: 12px}.dialog-header{position:sticky;top:0;z-index:1;display:flex;align-items:center;gap:var(--dlg-pad);padding:0 var(--dlg-pad);height:var(--dlg-header-h);margin:0;background:var(--md-sys-color-surface-container-high);border-bottom:1px solid var(--md-sys-color-outline-variant);color:var(--md-sys-color-on-surface)}.dialog-title{margin:0;font:inherit;font-weight:600;color:var(--md-sys-color-on-surface)}.spacer{flex:1}.dialog-content{overflow:auto;padding:var(--dlg-pad);max-height:calc(100svh - var(--dlg-header-h) - 32px)}.dialog-header button.mat-icon-button{color:var(--md-sys-color-on-surface-variant)}.dialog-header button.mat-icon-button:hover{color:var(--md-sys-color-primary);background:var(--md-sys-color-primary-container)}.dialog-footer{position:sticky;bottom:0;z-index:1;padding:var(--dlg-pad)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDialogModule }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }, { kind: "component", type: PraxisDynamicForm, selector: "praxis-dynamic-form", inputs: ["resourcePath", "resourceId", "editorialContext", "mode", "config", "schemaSource", "schemaUrl", "submitUrl", "submitMethod", "responseSchemaUrl", "apiEndpointKey", "apiUrlEntry", "enableCustomization", "formId", "componentInstanceId", "layout", "backConfig", "hooks", "removeEmptyContainersOnSave", "reactiveValidation", "reactiveValidationDebounceMs", "notifyIfOutdated", "snoozeMs", "autoOpenSettingsOnOutdated", "readonlyModeGlobal", "disabledModeGlobal", "presentationModeGlobal", "visibleGlobal", "customEndpoints"], outputs: ["formSubmit", "formCancel", "formReset", "configChange", "formReady", "valueChange", "syncCompleted", "initializationError", "loadingStateChange", "enableCustomizationChange", "customAction", "actionConfirmation", "schemaStatusChange", "fieldRenderError", "widgetEvent"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicFormDialogHostComponent, decorators: [{
             type: Component,
@@ -1060,6 +1736,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         [resourcePath]="resourcePath"
         [resourceId]="resourceId"
         [mode]="mode"
+        [schemaUrl]="schemaUrl"
+        [submitUrl]="submitUrl"
+        [submitMethod]="submitMethod"
+        [apiEndpointKey]="apiEndpointKey"
+        [apiUrlEntry]="apiUrlEntry"
         [presentationModeGlobal]="mode === 'view' ? true : null"
         [backConfig]="backConfig"
         (formSubmit)="onSave($event)"
@@ -1115,6 +1796,16 @@ const PRAXIS_CRUD_COMPONENT_METADATA = {
             type: 'Record<string, unknown>',
             description: 'Contexto opaco do host. A implementacao atual o expõe como Input, mas nao o consome no launcher nem no tableCrudContext.',
         },
+        {
+            name: 'metadata.queryContext',
+            type: 'PraxisDataQueryContext | null',
+            description: 'Contexto semantico de consulta encaminhado para a tabela interna do CRUD. Preferir este contrato para novo authoring remoto.',
+        },
+        {
+            name: 'metadata.filterCriteria',
+            type: 'Record<string, unknown> | null',
+            description: 'Bridge declarativa de filtros encaminhada para a tabela interna. Para novo authoring, prefira metadata.queryContext.',
+        },
         {
             name: 'enableCustomization',
             type: 'boolean',
@@ -1448,4 +2139,3 @@ const CRUD_AI_CAPABILITIES = {
  */
 
 export { CRUD_AI_CAPABILITIES, CrudLauncherService, CrudPageHeaderComponent, DialogService, DynamicFormDialogHostComponent, PRAXIS_CRUD_COMPONENT_METADATA, PraxisCrudComponent, assertCrudMetadata, providePraxisCrudMetadata };
-//# sourceMappingURL=praxisui-crud.mjs.map