@archbase/template 3.0.0 → 3.0.2

package/dist/template/src/ArchbaseFormModalTemplate.d.ts

@@ -0,0 +1,21 @@
+import { LoadingOverlayStylesNames, ModalProps } from '@mantine/core';
+import { CSSProperties, ReactNode } from 'react';
+import { ArchbaseDataSource } from '../../data/src';
+import { ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface ArchbaseFormModalTemplateProps<T extends object, ID> extends Omit<ModalProps, 'onClose' | 'onError'>, ArchbaseTemplateSecurityProps {
+    dataSource?: ArchbaseDataSource<T, ID>;
+    height: string | number | undefined;
+    userActions?: ReactNode;
+    onCustomSave?: (record?: T, callback?: Function) => void;
+    onAfterSave?: (record?: T) => void;
+    onClickOk: (record?: T, result?: any) => void;
+    onClickCancel: (record?: T) => void;
+    onBeforeOk?: (record?: T) => Promise<any> | boolean | undefined;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    onError?: (error: string) => void;
+    autoCloseAlertError?: number;
+    loadingOverlayStyles?: Partial<Record<LoadingOverlayStylesNames, CSSProperties>>;
+}
+export declare function ArchbaseFormModalTemplate<T extends object, ID>({ title, withOverlay, overlayProps, children, withCloseButton, closeButtonProps, opened, fullScreen, centered, variant, closeOnEscape, size, dataSource, height, userActions, onAfterSave, onClickOk, onClickCancel, onBeforeOk, onCustomSave, isError, error, clearError, onError, autoCloseAlertError, loadingOverlayStyles, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, ...rest }: ArchbaseFormModalTemplateProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbaseFormTemplate.d.ts

@@ -0,0 +1,35 @@
+import { AlertVariant, ButtonVariant } from '@mantine/core';
+import { default as React } from 'react';
+import { ArchbaseDataSource } from '../../data/src';
+import { ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface ArchbaseFormTemplateProps<T, ID> extends ArchbaseTemplateSecurityProps {
+    title: string;
+    dataSource: ArchbaseDataSource<T, ID>;
+    variant?: ButtonVariant | AlertVariant | string;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    isLoading?: boolean;
+    isCanceling?: boolean;
+    isSaving?: boolean;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    autoCloseAlertError?: number;
+    width?: number | string | undefined;
+    height?: number | string | undefined;
+    withBorder?: boolean;
+    children?: React.ReactNode | React.ReactNode[];
+    radius?: string | number | undefined;
+    /** Alinhamento dos botões no footer: 'left' | 'center' | 'right' */
+    footerAlign?: 'left' | 'center' | 'right';
+    /** Conteúdo adicional a ser exibido no footer (à esquerda dos botões se footerAlign='right', à direita se footerAlign='left') */
+    footerContent?: React.ReactNode;
+    onSave?: (entityToSave: any) => void;
+    onCancel?: () => void;
+    onBeforeSave?: (entityToSave: T) => void;
+    onAfterSave?: (savedEntity: T) => void;
+    onBeforeCancel?: () => void;
+    onAfterCancel?: () => void;
+    onError?: (error: string) => void;
+}
+export declare function ArchbaseFormTemplate<T extends object, ID>({ innerRef, title, isError, isCanceling, isSaving, error, clearError, autoCloseAlertError, width, height, withBorder, children, radius, variant, footerAlign, footerContent, dataSource, onSave, onCancel, onBeforeSave, onAfterSave, onBeforeCancel, onAfterCancel, onError, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, ...rest }: ArchbaseFormTemplateProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbaseGridTemplate.d.ts

@@ -0,0 +1,110 @@
+import { AlertVariant, ButtonVariant } from '@mantine/core';
+import { default as React, ReactNode } from 'react';
+import { ArchbaseDataGridRef, CellClickEvent } from '../../components/src';
+import { ArchbaseStateValues } from './ArchbaseStateValues';
+import { ArchbaseQueryFilterDelegator, FilterOptions } from '../../advanced/src';
+import { ArchbaseDataSource } from '../../data/src';
+import { ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface UserActionsOptions {
+    visible: boolean;
+    labelAdd?: string;
+    labelEdit?: string;
+    labelRemove?: string;
+    labelView?: string;
+    allowRemove: boolean;
+    customUserActions?: ReactNode;
+    customUserActionsPosition?: 'left' | 'right';
+    onAddExecute?: () => void;
+    onEditExecute?: () => void;
+    onRemoveExecute?: () => void;
+    onViewExecute?: () => void;
+}
+export interface UserRowActionsOptions<T extends Object> {
+    actions?: any;
+    onAddRow?: (row: T) => void;
+    onEditRow?: (row: T) => void;
+    onRemoveRow?: (row: T) => void;
+    onViewRow?: (row: T) => void;
+}
+export interface ArchbaseGridTemplateProps<T extends Object, ID> extends ArchbaseTemplateSecurityProps {
+    id?: string;
+    title: string;
+    printTitle?: string;
+    logoPrint?: string;
+    variant?: AlertVariant | ButtonVariant;
+    dataSource: ArchbaseDataSource<T, ID>;
+    dataSourceEdition?: ArchbaseDataSource<T, ID> | undefined;
+    store?: ArchbaseStateValues | undefined;
+    filterType: 'none' | 'normal' | 'advanced';
+    filterOptions?: FilterOptions;
+    filterPersistenceDelegator?: ArchbaseQueryFilterDelegator;
+    pageSize?: number;
+    pageIndex?: number;
+    columns: ReactNode;
+    filterFields?: ReactNode | undefined;
+    userActions?: UserActionsOptions;
+    userRowActions?: UserRowActionsOptions<T>;
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    isLoading?: boolean;
+    isLoadingFilter?: boolean;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    width?: number | string | undefined;
+    height?: number | string | undefined;
+    onSearchByFilter?: () => void;
+    getRowId?: (row: T) => any;
+    withBorder?: boolean;
+    enableTopToolbar?: boolean;
+    enableTopToolbarActions?: boolean;
+    cellPadding?: string | number;
+    bottomToolbarMinHeight?: string | number;
+    /** Habilitar seleção de linhas */
+    enableRowSelection?: boolean;
+    /** Habilitar números de linha */
+    enableRowNumbers?: boolean;
+    /** Habilitar ações nas linhas */
+    enableRowActions?: boolean;
+    /** Posição da coluna de ações */
+    positionActionsColumn: 'first' | 'last';
+    /** Padding da célula do cabeçalho da tabela */
+    tableHeadCellPadding?: string;
+    /** Função para renderizar o painel de detalhes */
+    renderDetailPanel?: (props: {
+        row: T;
+    }) => ReactNode;
+    /** Função para renderizar a barra de ferramentas superior */
+    renderTopToolbar?: ReactNode;
+    /** Alinhamento da toolbar */
+    toolbarAlignment?: 'left' | 'right';
+    /** Conteúdo da esquerda da toolbar */
+    toolbarLeftContent?: ReactNode;
+    /** Função chamada quando as linhas selecionadas mudam */
+    onSelectedRowsChanged?: (rows: T[]) => void;
+    /** Função chamada quando ocorre duplo clique em uma célula */
+    onCellDoubleClick?: (event: CellClickEvent) => void;
+    /** Função chamada quando o modelo de filtro da grid muda */
+    onFilterModelChange?: (filterModel: any) => void;
+    /** Labels para paginação */
+    paginationLabels?: {
+        totalRecords?: string;
+        pageSize?: string;
+        currentPage?: string;
+        of?: string;
+    };
+    customRenderRowActions?: (row: T) => ReactNode;
+}
+export interface ArchbaseGridTemplateRef {
+    refreshData: () => void;
+    getSelectedRows: () => any[];
+    clearSelection: () => void;
+    exportData: () => void;
+    printData: () => void;
+    getDataGridRef: () => React.RefObject<ArchbaseDataGridRef>;
+    getFilterModel: () => any;
+}
+declare function ArchbaseGridTemplateImpl<T extends object, ID>(props: ArchbaseGridTemplateProps<T, ID>, ref: React.ForwardedRef<ArchbaseGridTemplateRef>): import("react/jsx-runtime").JSX.Element;
+export declare const ArchbaseGridTemplate: <T extends object, ID>(props: ArchbaseGridTemplateProps<T, ID> & {
+    ref?: React.ForwardedRef<ArchbaseGridTemplateRef>;
+}) => ReturnType<typeof ArchbaseGridTemplateImpl>;
+export {};

package/dist/template/src/ArchbaseMasonryTemplate.d.ts

@@ -0,0 +1,76 @@
+import { default as React, CSSProperties, ReactNode } from 'react';
+import { ArchbaseAction, ArchbaseActionButtonsOptions } from '../../components/src';
+import { ComponentDefinition } from '../../core/src';
+import { ArchbaseDataSource } from '../../data/src';
+import { ArchbaseQueryFilterDelegator, FilterOptions } from '../../advanced/src';
+import { ArchbaseSpaceTemplateOptions } from './ArchbaseSpaceTemplate';
+import { ArchbaseDebugOptions, ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface MasonryUserActionsOptions {
+    visible?: boolean;
+    labelAdd?: string | undefined | null;
+    labelEdit?: string | undefined | null;
+    labelRemove?: string | undefined | null;
+    labelView?: string | undefined | null;
+    allowAdd?: boolean;
+    allowEdit?: boolean;
+    allowView?: boolean;
+    allowRemove?: boolean;
+    onAddExecute?: () => void;
+    onEditExecute?: () => void;
+    onRemoveExecute?: () => void;
+    onViewExecute?: () => void;
+    customUserActions?: ArchbaseAction[];
+    positionCustomUserActions?: 'before' | 'after';
+}
+export interface MasonryUserRowActionsOptions<T> {
+    actions?: any;
+    onAddRow?: (row: T) => void;
+    onEditRow?: (row: T) => void;
+    onRemoveRow?: (row: T) => void;
+    onViewRow?: (row: T) => void;
+}
+export interface ArchbaseMasonryTemplateProps<T, ID> extends ArchbaseTemplateSecurityProps {
+    title: string;
+    dataSource: ArchbaseDataSource<T, ID>;
+    dataSourceEdition?: ArchbaseDataSource<T, ID> | undefined;
+    filterType: 'none' | 'normal' | 'advanced';
+    globalFilterFieldNames?: string[];
+    filterOptions: FilterOptions;
+    pageSize?: number;
+    filterFields: ReactNode | undefined;
+    filterPersistenceDelegator: ArchbaseQueryFilterDelegator;
+    userActions?: MasonryUserActionsOptions;
+    variant?: string;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    isLoading?: boolean;
+    debug?: boolean;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    width?: number | string | undefined;
+    height?: number | string | undefined;
+    withBorder?: boolean;
+    withPagination?: boolean;
+    radius?: string | number | undefined;
+    columnsCountBreakPoints?: Record<number, number>;
+    columnsCount?: number;
+    gutter?: string;
+    /** Definições do componente customizado a ser renderizado para um Item da lista */
+    component?: ComponentDefinition;
+    id?: string;
+    activeIndex?: number;
+    /** Cor de fundo do item ativo */
+    activeBackgroundColor?: string;
+    /** Cor do item ativo */
+    activeColor?: string;
+    /** Evento gerado quando o mouse está sobre um item */
+    onItemEnter?: (event: React.MouseEvent, data: any) => void;
+    /** Evento gerado quando o mouse sai de um item */
+    onItemLeave?: (event: React.MouseEvent, data: any) => void;
+    style?: CSSProperties;
+    actionsButtonsOptions?: ArchbaseActionButtonsOptions;
+    spaceOptions?: ArchbaseSpaceTemplateOptions;
+    debugOptions?: ArchbaseDebugOptions;
+}
+export declare function ArchbaseMasonryTemplate<T extends object, ID>({ title, dataSource, filterOptions, globalFilterFieldNames, filterFields, innerRef, debug, filterType, isError, error, clearError, width, height, withBorder, filterPersistenceDelegator, withPagination, radius, userActions, columnsCountBreakPoints, columnsCount, gutter, component, activeIndex, activeBackgroundColor, activeColor, onItemEnter, onItemLeave, style, actionsButtonsOptions, spaceOptions, variant, id, debugOptions, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, }: ArchbaseMasonryTemplateProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbaseModalTemplate.d.ts

@@ -0,0 +1,11 @@
+import { ModalProps } from '@mantine/core';
+import { ReactNode } from 'react';
+import { ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface ArchbaseModalTemplateProps extends ModalProps, ArchbaseTemplateSecurityProps {
+    height: string | number | undefined;
+    userActions?: ReactNode;
+    onlyOkButton?: boolean;
+    onClickOk?: () => void;
+    onClickCancel?: () => void;
+}
+export declare function ArchbaseModalTemplate({ title, withOverlay, overlayProps, children, withCloseButton, closeButtonProps, opened, fullScreen, centered, variant, closeOnEscape, size, height, onlyOkButton, onClose, onClickOk, onClickCancel, userActions, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, }: ArchbaseModalTemplateProps): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbasePanelTemplate.d.ts

@@ -0,0 +1,60 @@
+import { ArchbaseAction, ArchbaseActionButtonsOptions } from '../../components/src';
+import { default as React, CSSProperties, ReactNode } from 'react';
+import { ArchbaseDataSource } from '../../data/src';
+import { ArchbaseQueryFilterDelegator, FilterOptions } from '../../advanced/src';
+import { ArchbaseSpaceTemplateOptions } from './ArchbaseSpaceTemplate';
+import { ArchbaseDebugOptions, ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+export interface PanelUserActionsOptions {
+    visible?: boolean;
+    labelAdd?: string;
+    labelEdit?: string;
+    labelRemove?: string;
+    labelView?: string;
+    allowAdd?: boolean;
+    allowEdit?: boolean;
+    allowView?: boolean;
+    allowRemove?: boolean;
+    onAddExecute?: () => void;
+    onEditExecute?: () => void;
+    onRemoveExecute?: () => void;
+    onView?: () => void;
+    customUserActions?: ArchbaseAction[];
+    positionCustomUserActions?: 'before' | 'after';
+}
+export interface PanelUserRowActionsOptions<T> {
+    actions?: any;
+    onAddRow?: (row: T) => void;
+    onEditRow?: (row: T) => void;
+    onRemoveRow?: (row: T) => void;
+    onViewRow?: (row: T) => void;
+    variant?: string;
+}
+export interface ArchbasePanelTemplateProps<T, ID> extends ArchbaseTemplateSecurityProps {
+    title: string;
+    dataSource: ArchbaseDataSource<T, ID>;
+    dataSourceEdition?: ArchbaseDataSource<T, ID> | undefined;
+    variant?: string;
+    filterOptions: FilterOptions;
+    pageSize?: number;
+    filterFields: ReactNode | undefined;
+    filterPersistenceDelegator: ArchbaseQueryFilterDelegator;
+    userActions?: PanelUserActionsOptions;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    isLoading?: boolean;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    width?: number | string | undefined;
+    height?: number | string | undefined;
+    withBorder?: boolean;
+    withPagination?: boolean;
+    children?: React.ReactNode;
+    radius?: number | string | undefined;
+    debug?: boolean;
+    actionsButtonsOptions?: ArchbaseActionButtonsOptions;
+    spaceOptions?: ArchbaseSpaceTemplateOptions;
+    style?: CSSProperties;
+    debugOptions?: ArchbaseDebugOptions;
+}
+export declare function ArchbasePanelTemplate<T extends object, ID>({ title, dataSource, filterOptions, filterFields, innerRef, isError, error, clearError, width, height, withBorder, filterPersistenceDelegator, withPagination, children, radius, userActions, debug, variant, actionsButtonsOptions, spaceOptions, style, debugOptions, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, }: ArchbasePanelTemplateProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbaseSearchTemplate.d.ts

@@ -0,0 +1 @@
+export declare function ArchbaseSearchTemplate(): import("react/jsx-runtime").JSX.Element;

package/dist/template/src/ArchbaseSpaceTemplate.d.ts

@@ -0,0 +1,70 @@
+import { AlertVariant, StyleProp, GridColProps } from '@mantine/core';
+import { default as React, CSSProperties, ReactNode } from 'react';
+import { ArchbaseDebugOptions, ArchbaseTemplateSecurityProps } from './ArchbaseTemplateCommonTypes';
+type ColSpan = GridColProps['span'];
+interface ArchbaseBreakpointsColSpans {
+    /** Col span em (min-width: theme.breakpoints.xs) */
+    xs?: ColSpan;
+    /** Col span em (min-width: theme.breakpoints.sm) */
+    sm?: ColSpan;
+    /** Col span em (min-width: theme.breakpoints.md) */
+    md?: ColSpan;
+    /** Col span em (min-width: theme.breakpoints.lg) */
+    lg?: ColSpan;
+    /** Col span em (min-width: theme.breakpoints.xl) */
+    xl?: ColSpan;
+}
+export interface ArchbaseSpaceTemplateOptions {
+    /** Indicar qual lado do header irá crescer para preencher o espaço sobrando (Válido somente quando headerGridColumns não é atribuído ao options) */
+    headerFlexGrow?: 'left' | 'even' | 'right';
+    /** Justificar o conteúdo interno da parte direita do header.*/
+    headerFlexRightJustifyContent?: StyleProp<React.CSSProperties['justifyContent']>;
+    /** Justificar o conteúdo interno da parte esquerda do header.*/
+    headerFlexLeftJustifyContent?: StyleProp<React.CSSProperties['justifyContent']>;
+    /** Indicar os ColSpan das grids para cada parte do header (left, middle, right) de acordo com os breakpoints */
+    headerGridColumns?: {
+        right?: ArchbaseBreakpointsColSpans;
+        middle?: ArchbaseBreakpointsColSpans;
+        left?: ArchbaseBreakpointsColSpans;
+    };
+    /** Indicar qual lado do footer irá crescer para preencher o espaço sobrando (Válido somente quando footerGridColumns não é atribuído ao options) */
+    footerFlexGrow?: 'left' | 'even' | 'right';
+    /** Justificar o conteúdo interno da parte direita do footer.*/
+    footerFlexRightJustifyContent?: StyleProp<React.CSSProperties['justifyContent']>;
+    /** Justificar o conteúdo interno da parte esquerda do footer.*/
+    footerFlexLeftJustifyContent?: StyleProp<React.CSSProperties['justifyContent']>;
+    /** Indicar os ColSpan das grids para cada parte do footer (left, middle, right) de acordo com os breakpoints */
+    footerGridColumns?: {
+        right?: ArchbaseBreakpointsColSpans;
+        middle?: ArchbaseBreakpointsColSpans;
+        left?: ArchbaseBreakpointsColSpans;
+    };
+}
+export interface ArchbaseSpaceTemplateProps<T, ID> extends ArchbaseTemplateSecurityProps {
+    title: string;
+    variant?: AlertVariant | string;
+    headerLeft?: ReactNode;
+    headerMiddle?: ReactNode;
+    headerRight?: ReactNode;
+    footerLeft?: ReactNode;
+    footerMiddle?: ReactNode;
+    footerRight?: ReactNode;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    width?: number | string | undefined;
+    height?: number | string | undefined;
+    withBorder?: boolean;
+    children?: React.ReactNode;
+    radius?: string | number | undefined;
+    debug?: boolean;
+    defaultDebug?: boolean;
+    isError?: boolean;
+    error?: string | undefined;
+    clearError?: () => void;
+    /** Opções de personalização */
+    options?: ArchbaseSpaceTemplateOptions;
+    style?: CSSProperties;
+    debugOptions?: ArchbaseDebugOptions;
+}
+export declare function ArchbaseSpaceTemplate<T extends object, ID>({ title, innerRef, isError, error, clearError, width, height, withBorder, children, radius, debug, defaultDebug, headerLeft, headerMiddle, headerRight, footerLeft, footerMiddle, footerRight, variant, options, style, debugOptions, resourceName, resourceDescription, requiredPermissions, fallbackComponent, securityOptions, }: ArchbaseSpaceTemplateProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/template/src/ArchbaseStateValues.d.ts

@@ -0,0 +1,9 @@
+export type ArchbaseStateValues = {
+    values: Map<string, any>;
+    setValue: (key: string, value: any) => void;
+    getValue: (key: any) => any;
+    existsValue: (key: string) => boolean;
+    clearValue: (key: string) => void;
+    clearAllValues: () => void;
+    reset: () => void;
+};

package/dist/template/src/ArchbaseTemplateCommonTypes.d.ts

@@ -0,0 +1,28 @@
+import { ArchbaseObjectToInspect } from '../../components/src';
+import { ReactNode } from 'react';
+export interface ArchbaseDebugOptions {
+    debugLayoutHotKey?: string;
+    debugObjectInspectorHotKey?: string;
+    objectsToInspect?: ArchbaseObjectToInspect[];
+}
+/**
+ * Props opcionais para integração de segurança em templates
+ * Completamente opcionais - se não fornecidas, template funciona normalmente
+ */
+export interface ArchbaseTemplateSecurityProps {
+    /** Nome do recurso - SE definido, ativa segurança */
+    resourceName?: string;
+    /** Descrição do recurso - opcional */
+    resourceDescription?: string;
+    /** Permissões obrigatórias - só válido SE resourceName definido */
+    requiredPermissions?: string[];
+    /** Fallback para acesso negado - só usado SE segurança ativa */
+    fallbackComponent?: ReactNode;
+    /** Configurações avançadas - só funciona SE segurança ativa */
+    securityOptions?: {
+        autoRegisterActions?: boolean;
+        strictMode?: boolean;
+        onSecurityReady?: (manager: any) => void;
+        onAccessDenied?: () => void;
+    };
+}

package/dist/template/src/ArchbaseTemplateState.d.ts

@@ -0,0 +1,9 @@
+import { ArchbaseRemoteDataSource } from '../../data/src';
+export type ArchbaseTemplateState<T, ID> = {
+    dataSource?: ArchbaseRemoteDataSource<T, ID>;
+    dataSourceEdition?: ArchbaseRemoteDataSource<T, ID>;
+    setDataSource: (ds: ArchbaseRemoteDataSource<T, ID>) => void;
+    setDataSourceEdition: (ds: ArchbaseRemoteDataSource<T, ID>) => void;
+    clearDataSource: () => void;
+    clearDataSourceEdition: () => void;
+};

package/dist/template/src/components/ArchbaseConditionalSecurityWrapper.d.ts

@@ -0,0 +1,34 @@
+import { default as React, ReactNode } from 'react';
+/**
+ * Wrapper ultra-leve que aplica segurança condicionalmente
+ * Se não tem resourceName ou contexto de segurança, apenas renderiza children
+ * Se tem ambos, envolve com ArchbaseViewSecurityProvider
+ *
+ * IMPORTANTE: Este componente é otimizado para evitar re-renders desnecessários
+ */
+interface ConditionalSecurityWrapperProps {
+    children: ReactNode;
+    /** Se não fornecido, não envolve com segurança */
+    resourceName?: string;
+    /** Descrição opcional do recurso */
+    resourceDescription?: string;
+    /** Permissões obrigatórias para acessar */
+    requiredPermissions?: string[];
+    /** Componente de fallback se acesso negado */
+    fallbackComponent?: ReactNode;
+    /** Callback quando segurança está pronta */
+    onSecurityReady?: (manager: any) => void;
+    /** Callback quando acesso negado */
+    onAccessDenied?: () => void;
+}
+export declare const ArchbaseConditionalSecurityWrapper: React.FC<ConditionalSecurityWrapperProps>;
+/**
+ * Hook para verificar se deve aplicar wrapper de segurança
+ * IMPORTANTE: Retorna valor estável para evitar re-renders infinitos
+ */
+export declare const useConditionalSecurity: (resourceName?: string) => {
+    shouldWrap: boolean;
+    isSecurityAvailable: boolean;
+    hasResourceName: boolean;
+};
+export {};

package/dist/template/src/components/ArchbaseSmartActionButton.d.ts

@@ -0,0 +1,27 @@
+import { default as React, ReactNode } from 'react';
+import { ButtonProps } from '@mantine/core';
+/**
+ * Botão inteligente que detecta contexto de segurança
+ * Se não tem contexto ou ação não especificada, renderiza botão normal
+ * Se tem contexto e ação, verifica permissão antes de renderizar
+ */
+interface ArchbaseSmartActionButtonProps extends Omit<ButtonProps, 'onClick'> {
+    /** Nome da ação para verificar permissão - se não fornecido, sempre renderiza */
+    actionName?: string;
+    /** Descrição da ação para auto-registro */
+    actionDescription?: string;
+    /** Conteúdo do botão */
+    children: ReactNode;
+    /** Componente alternativo se não tem permissão */
+    fallback?: ReactNode;
+    /** Se deve auto-registrar a ação */
+    autoRegister?: boolean;
+    /** Função onClick */
+    onClick?: () => void;
+}
+export declare const ArchbaseSmartActionButton: React.FC<ArchbaseSmartActionButtonProps>;
+/**
+ * Versão mais avançada que usa diretamente o sistema de segurança quando disponível
+ */
+export declare const ArchbaseAdvancedSmartButton: React.FC<ArchbaseSmartActionButtonProps>;
+export {};

package/dist/template/src/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ArchbaseSmartActionButton';
+export * from './ArchbaseConditionalSecurityWrapper';

package/dist/template/src/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useOptionalTemplateSecurity';

package/dist/template/src/hooks/useOptionalTemplateSecurity.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hook que funciona com ou sem contexto de segurança
+ * Se não há contexto de segurança, sempre retorna true (permite tudo)
+ * Se há contexto de segurança, usa as verificações reais
+ *
+ * IMPORTANTE: Retorna objeto estável para evitar re-renders infinitos
+ */
+export declare const useOptionalTemplateSecurity: (config?: {
+    resourceName?: string;
+    resourceDescription?: string;
+    autoRegisterActions?: boolean;
+}) => {
+    readonly isAvailable: false;
+    readonly hasPermission: () => boolean;
+    readonly registerAction: () => void;
+    readonly canCreate: true;
+    readonly canEdit: true;
+    readonly canDelete: true;
+    readonly canView: true;
+};
+/**
+ * Hook mais direto para verificar se contexto de segurança está disponível
+ * IMPORTANTE: Retorna valor estável para evitar re-renders
+ */
+export declare const useTemplateSecurityAvailable: () => boolean;

package/dist/template/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './ArchbaseFormTemplate';
+export * from './ArchbaseFormModalTemplate';
+export * from './ArchbaseModalTemplate';
+export * from './ArchbaseGridTemplate';
+export * from './ArchbaseMasonryTemplate';
+export * from './ArchbasePanelTemplate';
+export * from './ArchbaseSpaceTemplate';
+export * from './ArchbaseSearchTemplate';
+export * from './ArchbaseTemplateCommonTypes';
+export * from './ArchbaseTemplateState';
+export * from './ArchbaseStateValues';
+export * from './components';
+export * from './hooks';
+export * from './validation/ValidationErrorsContext';

package/dist/template/src/validation/ValidationErrorsContext.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+export interface ValidationErrorsContextType {
+    errors: Record<string, string>;
+    setError: (field: string, error: string) => void;
+    clearError: (field: string) => void;
+    clearAll: () => void;
+    getError: (field: string) => string | undefined;
+}
+/**
+ * Provider para gerenciar erros de validação de formulários
+ * Armazena erros em um estado global que sobrevive a unmounts de componentes
+ */
+export declare function ValidationErrorsProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook para acessar o contexto de erros de validação
+ * Retorna undefined se o contexto não estiver disponível (para compatibilidade)
+ */
+export declare function useValidationErrors(): ValidationErrorsContextType | undefined;
+/**
+ * Hook que sempre retorna um contexto de erros (cria um vazio se não existir)
+ * Use quando você PRECISA do contexto
+ */
+export declare function useRequiredValidationErrors(): ValidationErrorsContextType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/template",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Template components for Archbase React v3 - High-level templates and layouts",
   "author": "Edson Martins <edsonmartins2005@gmail.com>",
   "license": "MIT",
@@ -13,48 +13,50 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
-    }
+    },
+    "./dist/index.css": "./dist/index.css"
   },
   "files": [
     "dist",
     "README.md"
   ],
   "peerDependencies": {
-    "react": "^18.3.0 || ^19.0.0",
-    "react-dom": "^18.3.0 || ^19.0.0",
     "@mantine/core": "8.3.12",
     "@mantine/dates": "8.3.12",
     "@mantine/hooks": "8.3.12",
     "@mantine/modals": "8.3.12",
-    "@tabler/icons-react": "^3.26.0"
+    "@tabler/icons-react": "^3.26.0",
+    "react": "^18.3.0 || ^19.2.0",
+    "react-dom": "^18.3.0 || ^19.2.0"
   },
   "dependencies": {
+    "@archbase/advanced": "3.0.2",
+    "@archbase/components": "3.0.2",
+    "@archbase/core": "3.0.2",
+    "@archbase/data": "3.0.2",
+    "@archbase/layout": "3.0.2",
+    "@archbase/security": "3.0.2",
+    "@archbase/security-ui": "3.0.2",
+    "@rehooks/component-size": "^1.0.3",
     "dayjs": "^1.11.13",
     "i18next": "^25.3.1",
-    "react-i18next": "^15.1.2",
     "lodash": "^4.17.21",
-    "@rehooks/component-size": "^1.0.3",
-    "@archbase/core": "3.0.0",
-    "@archbase/data": "3.0.0",
-    "@archbase/layout": "3.0.0",
-    "@archbase/advanced": "3.0.0",
-    "@archbase/components": "3.0.0",
-    "@archbase/security": "3.0.0",
-    "@archbase/security-ui": "3.0.0"
+    "react-i18next": "^15.1.2"
   },
   "devDependencies": {
-    "@types/react": "^19.0.4",
+    "@types/react": "^19.0.6",
     "@types/react-dom": "^19.0.2",
     "@vitejs/plugin-react": "^4.3.4",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
     "typescript": "~5.7.2",
     "vite": "^6.0.3",
+    "vite-plugin-dts": "^4.5.4",
     "vitest": "^2.1.8"
   },
   "scripts": {
     "dev": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build --watch",
-    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build && NODE_OPTIONS=\"--max-old-space-size=16384\" tsc --emitDeclarationOnly || true",
+    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",