@archbase/security-ui 4.1.0 → 4.2.0

package/dist/securityDiagnostics/ArchbaseSecurityDiagnosticsView.d.ts

@@ -0,0 +1,20 @@
+import { ArchbaseSecurityDiagnosticsViewProps } from './types';
+/**
+ * A segurança do tenant como um diretório navegável — o <b>leitor</b>.
+ *
+ * <p>Deliberadamente separada da {@link ArchbaseSecurityView}, que é o <b>editor</b>: aquela tem uma
+ * aba por tabela e serve para mudar o estado; esta responde perguntas e não escreve nada. Misturá-las
+ * produziria uma tela com dois motivos para mudar.
+ *
+ * <p><b>Por que árvore, e não abas.</b> As três abas anteriores — panorama, efetivo e simulação —
+ * respondiam três perguntas sem se conversarem: descobrir uma permissão inerte no panorama não
+ * levava a lugar nenhum, e simular exigia digitar de cabeça o nome do recurso. Uma árvore de
+ * objetos, no espírito de um AD, dá <b>uma</b> navegação: seleciona-se o objeto e se vê tudo sobre
+ * ele, incluindo o caminho para o próximo.
+ *
+ * <p>Panorama e Simular continuam existindo — como nós da mesma árvore, não como abas paralelas. É
+ * o que permite a simulação receber sujeito e capacidade por clique, em vez de digitação: <b>escolher
+ * substitui lembrar</b>, e errar uma letra deixa de produzir um "não pode" indistinguível de uma
+ * negação real.
+ */
+export declare const ArchbaseSecurityDiagnosticsView: ({ height, width, slots, onError, }: ArchbaseSecurityDiagnosticsViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/DiagnosticPrimitives.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { ArchbaseDiagnosticAttribute, ArchbaseDiagnosticCard, ArchbaseDiagnosticFlag, ArchbaseDiagnosticSeverity } from './types';
+/** Cor semântica — separada do acento visual do tema, de propósito. */
+export declare const severityColor: (severity: ArchbaseDiagnosticSeverity) => string;
+export interface MetricCardProps {
+    card: ArchbaseDiagnosticCard;
+    /**
+     * Abre o detalhe do card. Ausente quando a métrica não tem lista por trás — e aí o cartão não
+     * fica clicável, para não prometer uma navegação que não existe.
+     */
+    onOpen?: (card: ArchbaseDiagnosticCard) => void;
+}
+/** Cartão de métrica: valor grande, denominador, rótulo e o porquê importa. */
+export declare const MetricCard: ({ card, onOpen }: MetricCardProps) => import("react/jsx-runtime").JSX.Element;
+export interface MetricCardsProps {
+    cards: ArchbaseDiagnosticCard[];
+    onOpenCard?: (card: ArchbaseDiagnosticCard) => void;
+}
+export declare const MetricCards: ({ cards, onOpenCard }: MetricCardsProps) => import("react/jsx-runtime").JSX.Element;
+export interface FlagStripProps {
+    flags: ArchbaseDiagnosticFlag[];
+}
+/**
+ * Faixa de proteções.
+ *
+ * <p>Vem antes dos números na tela porque contagem alta de permissões não significa nada se o
+ * portão correspondente está inerte — e essa é a pergunta que o operador não sabe fazer.
+ */
+export declare const FlagStrip: ({ flags }: FlagStripProps) => import("react/jsx-runtime").JSX.Element;
+export interface AttributeListProps {
+    attributes: ArchbaseDiagnosticAttribute[];
+}
+/** Lista rótulo/valor — o layout onde entram perfil, grupos, nível e os atributos de negócio. */
+export declare const AttributeList: ({ attributes }: AttributeListProps) => import("react/jsx-runtime").JSX.Element;
+export interface SectionProps {
+    title: string;
+    hint?: string;
+    children: ReactNode;
+}
+export declare const Section: ({ title, hint, children }: SectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/EffectiveAccessPanel.d.ts

@@ -0,0 +1,13 @@
+import { ArchbaseSecurityDiagnosticsSlots } from './types';
+export interface EffectiveAccessPanelProps {
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    onError?: (message: string) => void;
+    /**
+     * Pessoa escolhida fora do painel — na árvore do explorador.
+     *
+     * Quando presente, o painel consulta sozinho e a caixa de busca some: escolher na árvore já é a
+     * busca, e deixar as duas na tela faria a pessoa se perguntar qual das duas vale.
+     */
+    userId?: string;
+}
+export declare const EffectiveAccessPanel: ({ slots, onError, userId }: EffectiveAccessPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/OverviewItemsDrawer.d.ts

@@ -0,0 +1,18 @@
+import { ArchbaseDiagnosticCard } from './types';
+export interface OverviewItemsDrawerProps {
+    /** O cartão clicado. `null` mantém o painel fechado. */
+    card: ArchbaseDiagnosticCard | null;
+    onClose: () => void;
+}
+/**
+ * A lista por trás de um número do Panorama.
+ *
+ * <p>Um cartão diz "29 ações inativas". Sozinho, isso informa que existe um problema e não permite
+ * fazer nada a respeito — para agir é preciso saber <b>quais</b> são, e por quê. Este painel é o que
+ * transforma o Panorama de tela de leitura em ponto de partida de trabalho.
+ *
+ * <p>É um só para as seis métricas, e não seis listas: o backend devolve a mesma forma
+ * ({@code label} / {@code detail} / {@code reason}) para permissões, usuários, ações e recursos.
+ * Seis telas divergiriam com o tempo; esta acompanha qualquer métrica nova sem alteração.
+ */
+export declare const OverviewItemsDrawer: ({ card, onClose }: OverviewItemsDrawerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/OverviewPanel.d.ts

@@ -0,0 +1,6 @@
+import { ArchbaseSecurityDiagnosticsSlots } from './types';
+export interface OverviewPanelProps {
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    onError?: (message: string) => void;
+}
+export declare const OverviewPanel: ({ slots, onError }: OverviewPanelProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/securityDiagnostics/SimulationPanel.d.ts

@@ -0,0 +1,20 @@
+import { ArchbaseSecurityDiagnosticsSlots } from './types';
+export interface SimulationPanelProps {
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    onError?: (message: string) => void;
+    /**
+     * Sujeito e capacidade escolhidos na árvore.
+     *
+     * <p><b>Escolher substitui lembrar.</b> Digitar {@code tms.ordemservico} de cabeça é a origem do
+     * falso negativo: errar uma letra devolve "não pode", indistinguível de uma negação real. Com a
+     * escolha vinda da árvore, a resposta passa a significar o que diz.
+     *
+     * <p>Os campos continuam editáveis — a árvore preenche, não tranca.
+     */
+    initial?: {
+        userId?: string;
+        resource?: string;
+        action?: string;
+    };
+}
+export declare const SimulationPanel: ({ slots, onError, initial }: SimulationPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/explorer/ActionNodePanel.d.ts

@@ -0,0 +1,19 @@
+import { ArchbaseSecurityDiagnosticsSlots } from '../types';
+export interface ActionNodePanelProps {
+    id: string;
+    label: string;
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    onSelectUser?: (userId: string, label: string) => void;
+    onSimulate?: () => void;
+}
+/**
+ * Quem alcança esta capacidade — a consulta reversa.
+ *
+ * <p><b>A pergunta que antes não tinha resposta.</b> "Quem consegue aprovar custo?" só se
+ * respondia abrindo grupo por grupo no admin e cruzando na cabeça, com resultado que dependia de
+ * quem cruzou.
+ *
+ * <p>Administrador aparece na lista com a via marcada. Ele alcança sem concessão nenhuma, e
+ * omiti-lo daria a resposta errada justamente para as contas que mais importam numa auditoria.
+ */
+export declare const ActionNodePanel: ({ id, label, slots, onSelectUser, onSimulate }: ActionNodePanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/explorer/GroupNodePanel.d.ts

@@ -0,0 +1,19 @@
+import { ArchbaseSecurityDiagnosticsSlots } from '../types';
+export interface GroupNodePanelProps {
+    id: string;
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    /** `PROFILE` troca o endpoint e o texto; a forma da resposta é a mesma de propósito. */
+    kind: 'GROUP' | 'PROFILE';
+    onSelectUser?: (userId: string, label: string) => void;
+}
+/**
+ * O que uma via concede, e quem está nela.
+ *
+ * <p><b>Os dois juntos porque separados enganam.</b> Ver o que o grupo concede não diz o que seus
+ * membros podem: cada um acumula o perfil, os outros grupos e as concessões diretas. Um grupo com
+ * três capacidades pode ter um membro que faz tudo, por outra via — e é o total que decide o acesso.
+ *
+ * <p>Grupo e perfil compartilham este painel de propósito: para quem lê, é a mesma pergunta, muda só
+ * a via. Duas telas obrigariam a aprender duas coisas para uma ideia.
+ */
+export declare const GroupNodePanel: ({ id, kind, slots, onSelectUser }: GroupNodePanelProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/securityDiagnostics/explorer/SecurityTree.d.ts

@@ -0,0 +1,19 @@
+import { ExplorerSelection } from './selection';
+export interface SecurityTreeProps {
+    selected: ExplorerSelection | null;
+    onSelect: (selecao: ExplorerSelection) => void;
+}
+/**
+ * A árvore de objetos de segurança.
+ *
+ * <p><b>Carrega por demanda, ramo a ramo.</b> Um tenant real tem centenas de recursos e ações;
+ * montar a árvore inteira numa carga obriga o servidor a materializar o catálogo para exibir cinco
+ * linhas, e trava o navegador ao renderizar. Cada ramo busca ao abrir, e a busca vai para o
+ * servidor — filtrar no cliente exigiria ter carregado tudo antes, que é o problema que a
+ * paginação existe para evitar.
+ *
+ * <p>O marcador colorido no nó vem do servidor e é o que leva o olho até onde há problema. Sem ele,
+ * achar um recurso com ação desativada entre uma centena exige abrir ramo por ramo — e ninguém faz
+ * isso.
+ */
+export declare const SecurityTree: ({ selected, onSelect }: SecurityTreeProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityDiagnostics/explorer/selection.d.ts

@@ -0,0 +1,15 @@
+import { ArchbaseTreeNodeKind } from '@archbase/security';
+/**
+ * O que está selecionado na árvore.
+ *
+ * <p>Os dois primeiros não são objetos do catálogo: são as duas ferramentas que antes eram abas
+ * próprias. Tratá-los como nós da mesma árvore é o que faz a tela ter <b>uma</b> navegação em vez
+ * de duas — e é o que permite a simulação receber o sujeito e a capacidade por clique, em vez de
+ * digitação.
+ */
+export type ExplorerSelectionKind = ArchbaseTreeNodeKind | 'OVERVIEW' | 'SIMULATE';
+export interface ExplorerSelection {
+    kind: ExplorerSelectionKind;
+    id: string;
+    label: string;
+}

package/dist/securityDiagnostics/explorer/situacao.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+/**
+ * A situação de uma concessão, em linguagem de quem opera.
+ *
+ * <p>O backend fala {@code EFFECTIVE}, {@code INERT} e {@code DENIED} — vocabulário do modelo. Quem
+ * lê a tela quer saber se a permissão <b>vale</b>. "Inerte" não é palavra que alguém use para
+ * decidir o que fazer; "não vale" é.
+ *
+ * <p>A tradução fica num lugar só de propósito: repetida em cada painel, uma tela acabaria dizendo
+ * "inerte" e outra "não vale" para a mesma coisa.
+ */
+export declare const situacaoBadge: (situacao?: string | null) => ReactNode;

package/dist/securityDiagnostics/index.d.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './DiagnosticPrimitives';
+export * from './OverviewPanel';
+export * from './OverviewItemsDrawer';
+export * from './EffectiveAccessPanel';
+export * from './SimulationPanel';
+export * from './ArchbaseSecurityDiagnosticsView';
+export * from './explorer/SecurityTree';
+export * from './explorer/GroupNodePanel';
+export * from './explorer/ActionNodePanel';
+export * from './explorer/selection';
+export * from './explorer/situacao';

package/dist/securityDiagnostics/types.d.ts

@@ -0,0 +1,137 @@
+import { ReactNode } from 'react';
+import { ArchbaseAccessDecision, ArchbaseAccessOverview, ArchbaseEffectiveAccessReport, ArchbaseEffectiveCapability, ArchbaseGroupMember, ArchbaseGroupReport, ArchbaseOverviewMetric, ArchbaseReachEntry } from '@archbase/security';
+/**
+ * Um atributo de negócio exibido no painel de identidade — rótulo e valor.
+ *
+ * <p>Existe para o caso mais comum de composição: a aplicação sabe o departamento, o centro
+ * de custo, a matrícula; o framework não sabe e não deveria saber. Entregando <b>dado</b> em
+ * vez de JSX, o atributo sai no mesmo layout de "Perfil / Grupos / Nível" — sem cada projeto
+ * inventar a própria formatação de rótulo.
+ */
+export interface ArchbaseDiagnosticAttribute {
+    label: string;
+    value: ReactNode;
+}
+/** Severidade de um cartão ou indicador. Separada do acento visual, de propósito. */
+export type ArchbaseDiagnosticSeverity = 'critical' | 'warning' | 'ok' | 'neutral';
+/** Cartão de métrica no Panorama, no mesmo formato dos que o framework desenha. */
+export interface ArchbaseDiagnosticCard {
+    severity: ArchbaseDiagnosticSeverity;
+    value: ReactNode;
+    /** Denominador ou unidade — "de 61 usuários". */
+    of?: string;
+    label: string;
+    description?: string;
+    /**
+     * A métrica cujos itens este cartão representa.
+     *
+     * Presente, o cartão fica clicável e abre a lista do que forma o número — que é o que permite
+     * agir: "29 ações inativas" não diz quais. Ausente (caso dos cartões de negócio injetados por
+     * slot, que o framework não sabe detalhar), o cartão continua só de leitura.
+     */
+    metric?: ArchbaseOverviewMetric;
+}
+/** Indicador de proteção ligada/desligada, na faixa do topo do Panorama. */
+export interface ArchbaseDiagnosticFlag {
+    key: string;
+    label: string;
+    value: string;
+    severity: ArchbaseDiagnosticSeverity;
+    description?: string;
+}
+/**
+ * Pontos de inserção da view — os <b>slots</b>.
+ *
+ * <p><b>Três verbos, três significados.</b> A regra vale para toda a view e é o que evita que
+ * a extensão vire colcha de retalhos:
+ *
+ * <ul>
+ *   <li>{@code before<X>} / {@code after<X>} — <b>insere</b> um nó antes ou depois da região
+ *       X, que continua desenhada pelo framework. É a convenção que a
+ *       {@code ArchbaseSecurityView} já usa em {@code beforeDefaultUserActions}.</li>
+ *   <li>{@code additional<X>} — <b>acrescenta dado</b> a uma coleção que o framework desenha.
+ *       A aplicação entrega o dado, não o JSX, e a coerência visual se mantém sozinha.</li>
+ *   <li>{@code render<X>} — <b>substitui</b> a região inteira. Válvula de escape, para quando
+ *       o que o framework desenha não serve.</li>
+ * </ul>
+ *
+ * <p>Prefira {@code additional} ao {@code render} sempre que couber: é o que mantém as telas
+ * de todos os produtos parecidas entre si.
+ */
+export interface ArchbaseSecurityDiagnosticsSlots {
+    /** Indicadores de proteção da própria aplicação, ao lado dos do framework. */
+    additionalFlags?: (overview: ArchbaseAccessOverview) => ArchbaseDiagnosticFlag[];
+    /** Cartões de métrica de negócio, na mesma grade e linguagem visual. */
+    additionalOverviewCards?: (overview: ArchbaseAccessOverview) => ArchbaseDiagnosticCard[];
+    /** Região livre no fim do Panorama — painel próprio, gráfico, link para relatório. */
+    afterOverview?: (overview: ArchbaseAccessOverview) => ReactNode;
+    /**
+     * Uma segunda porta de entrada para chegar a uma pessoa, acima da árvore.
+     *
+     * <p>É por aqui que entra "buscar pessoa por departamento": o framework identifica alguém por id
+     * ou e-mail e não tem como saber o que é departamento.
+     *
+     * <p><b>Mudou de lugar, não de propósito.</b> Quando a tela era um formulário, este slot
+     * substituía a caixa de busca. Agora a árvore é a navegação, e o que a aplicação oferece aparece
+     * ao lado dela — as duas convivem, porque quem sabe o e-mail usa a árvore e quem sabe só o
+     * departamento usa isto.
+     */
+    renderUserSearch?: (onSelect: (userIdOrEmail: string) => void) => ReactNode;
+    /** Selos ao lado do nome — "terceirizado", "afastado", "contrato vencido". */
+    afterUserBadges?: (report: ArchbaseEffectiveAccessReport) => ReactNode;
+    /** Atributos de negócio no painel de identidade. O lugar dos departamentos. */
+    userAttributes?: (report: ArchbaseEffectiveAccessReport) => ArchbaseDiagnosticAttribute[];
+    /** Entre os contadores e a tabela de capacidades. */
+    afterEffectiveTally?: (report: ArchbaseEffectiveAccessReport) => ReactNode;
+    /** Colunas extras na tabela, com o cabeçalho e o conteúdo por linha. */
+    additionalCapabilityColumns?: Array<{
+        header: string;
+        render: (capability: ArchbaseEffectiveCapability, report: ArchbaseEffectiveAccessReport) => ReactNode;
+    }>;
+    /**
+     * Colunas extras na tabela de membros — o lugar do departamento, do centro de custo.
+     *
+     * <p>Mesma convenção da tabela de capacidades: a aplicação entrega cabeçalho e conteúdo por
+     * linha, e o framework desenha.
+     */
+    additionalMemberColumns?: Array<{
+        header: string;
+        render: (member: ArchbaseGroupMember, report: ArchbaseGroupReport) => ReactNode;
+    }>;
+    /** Região livre no fim do painel de grupo ou perfil. */
+    afterGroupMembers?: (report: ArchbaseGroupReport) => ReactNode;
+    /**
+     * Região livre depois da lista de quem alcança uma capacidade.
+     *
+     * <p>O lugar de um "exportar para auditoria" ou de um aviso próprio da aplicação sobre aquela
+     * capacidade.
+     */
+    afterReachList?: (actionId: string, entries: ArchbaseReachEntry[]) => ReactNode;
+    /**
+     * Campos de negócio no formulário de simulação.
+     *
+     * <p><b>Limite:</b> o que for coletado aqui só chega ao servidor se a aplicação mapear para
+     * {@code companyId} ou {@code projectId} pelo {@code onScopeChange} — o avaliador não
+     * conhece outra dimensão de escopo.
+     */
+    afterSimulationFields?: (onScopeChange: (scope: {
+        companyId?: string;
+        projectId?: string;
+    }) => void) => ReactNode;
+    /** Depois do veredito — a tradução do motivo técnico para a linguagem do negócio. */
+    afterDecision?: (decision: ArchbaseAccessDecision) => ReactNode;
+}
+/**
+ * Props da view de diagnóstico.
+ *
+ * <p>Não há mais {@code defaultTab} nem {@code tabs}: a tela deixou de ser um conjunto de abas
+ * paralelas e virou um explorador de árvore. Panorama e Simular continuam existindo, como nós — e
+ * restringir quais nós aparecem seria esconder objetos de segurança de quem está auditando, que é o
+ * oposto do que a tela existe para fazer.
+ */
+export interface ArchbaseSecurityDiagnosticsViewProps {
+    height?: string | number;
+    width?: string | number;
+    slots?: ArchbaseSecurityDiagnosticsSlots;
+    onError?: (message: string) => void;
+}

package/dist/securityView/SecurityGridPanel.d.ts

@@ -0,0 +1,22 @@
+import { default as React, ReactNode } from 'react';
+import { ArchbaseDataGridRef } from '@archbase/components';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface SecurityGridPanelProps<T extends object> {
+    /** Aba visível. A escondida permanece montada. */
+    active: boolean;
+    printTitle: string;
+    gridRef: React.MutableRefObject<ArchbaseDataGridRef | null>;
+    dataSource: IArchbaseDataSourceBase<T>;
+    isLoading: boolean;
+    error?: string;
+    getRowId: (row: T) => string;
+    striped?: boolean;
+    /** Recursos e tokens de acesso não têm ações por linha. */
+    enableRowActions?: boolean;
+    toolbarLeftContent?: ReactNode;
+    renderRowActions?: (row: T) => ReactNode;
+    actionsColumnWidth?: number;
+    /** As colunas, no formato declarativo do grid. */
+    children: ReactNode;
+}
+export declare function SecurityGridPanel<T extends object>({ active, printTitle, gridRef, dataSource, isLoading, error, getRowId, striped, enableRowActions, toolbarLeftContent, renderRowActions, actionsColumnWidth, children, }: SecurityGridPanelProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/securityView/SecurityRowActions.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { TranslateFn } from './columns';
+export interface SecurityRowActionsProps<T> {
+    row: T;
+    onView: (row: T) => void;
+    onEdit: (row: T) => void;
+    onRemove: (row: T) => void;
+    onEditPermissions: () => void;
+    /** Slot: entra antes das ações padrão. */
+    before?: (row: T) => ReactNode;
+    /** Slot: entra depois das ações padrão. */
+    after?: (row: T) => ReactNode;
+    t: TranslateFn;
+}
+export declare function SecurityRowActions<T>({ row, onView, onEdit, onRemove, onEditPermissions, before, after, t, }: SecurityRowActionsProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/securityView/SecurityToolbarActions.d.ts

@@ -0,0 +1,7 @@
+import { TranslateFn } from './columns';
+export interface SecurityToolbarActionsProps {
+    onAdd: () => void;
+    onEditPermissions: () => void;
+    t: TranslateFn;
+}
+export declare const SecurityToolbarActions: ({ onAdd, onEditPermissions, t }: SecurityToolbarActionsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityView/UserItem.d.ts

@@ -0,0 +1,7 @@
+import { ArchbaseListCustomItemProps } from '@archbase/components';
+import { UserDto } from '@archbase/security';
+export declare const renderGroups: (user: UserDto) => import("react/jsx-runtime").JSX.Element | null;
+export declare const renderProfile: (user: UserDto) => import("react/jsx-runtime").JSX.Element | null;
+export interface UserItemProps extends ArchbaseListCustomItemProps<UserDto, string> {
+}
+export declare const UserItem: (props: UserItemProps) => import("react/jsx-runtime").JSX.Element;

package/dist/securityView/columns.d.ts

@@ -0,0 +1,8 @@
+/** A função de tradução do {@code useArchbaseTranslation}. */
+/** Assinatura do `t` devolvido por useArchbaseTranslation. */
+export type TranslateFn = (chave: string, opcoes?: any) => string | object;
+export declare const buildAccessTokenColumns: (t: TranslateFn) => import("react/jsx-runtime").JSX.Element;
+export declare const buildUserColumns: (t: TranslateFn) => import("react/jsx-runtime").JSX.Element;
+export declare const buildGroupColumns: (t: TranslateFn) => import("react/jsx-runtime").JSX.Element;
+export declare const buildProfileColumns: (t: TranslateFn) => import("react/jsx-runtime").JSX.Element;
+export declare const buildResourceColumns: (t: TranslateFn) => import("react/jsx-runtime").JSX.Element;

package/dist/securityView/index.d.ts

@@ -0,0 +1,8 @@
+export * from './noUserAvatar';
+export * from './types';
+export * from './UserItem';
+export * from './columns';
+export * from './SecurityGridPanel';
+export * from './useSecurityEntityActions';
+export * from './SecurityRowActions';
+export * from './SecurityToolbarActions';

package/dist/securityView/noUserAvatar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Avatar exibido quando o usuário não tem imagem.
+ *
+ * Mora em arquivo próprio porque são ~2 KB de base64 no meio do código: dentro da view
+ * ele empurrava a lógica para baixo da dobra em qualquer editor.
+ */
+export declare const NO_USER = "data:image/png;base64,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";

package/dist/securityView/types.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+import { ArchbaseDataSource } from '@archbase/data';
+import { GroupDto, ProfileDto, UserDto } from '@archbase/security';
+import { GroupModalOptions } from '../GroupModal';
+import { ProfileModalOptions } from '../ProfileModal';
+import { UserModalOptions } from '../UserModal';
+/**
+ * Pontos de inserção da view — os <b>slots</b>.
+ *
+ * <p>A convenção é {@code before<Região>} / {@code after<Região>}: a aplicação devolve o
+ * nó a inserir e o framework decide onde ele cai. É o que permite compor informação de
+ * negócio (departamento, centro de custo, contrato) numa tela que o framework desenha,
+ * sem que o framework precise conhecer esses conceitos.
+ */
+export interface ArchbaseSecurityProps {
+    beforeDefaultUserActions?: (row: UserDto) => ReactNode;
+    afterDefaultUserActions?: (row: UserDto) => ReactNode;
+    beforeDefaultProfileActions?: (row: ProfileDto) => ReactNode;
+    afterDefaultProfileActions?: (row: ProfileDto) => ReactNode;
+    beforeDefaultGroupActions?: (row: GroupDto) => ReactNode;
+    afterDefaultGroupActions?: (row: GroupDto) => ReactNode;
+    userActionsColumnWidth?: number;
+    profileActionsColumnWidth?: number;
+    groupActionsColumnWidth?: number;
+}
+export interface ArchbaseSecurityManagerProps {
+    height?: any;
+    width?: any;
+    dataSourceUsers?: ArchbaseDataSource<UserDto, string>;
+    createEntitiesWithId?: boolean;
+    userModalOptions?: UserModalOptions;
+    groupModalOptions?: GroupModalOptions;
+    profileModalOptions?: ProfileModalOptions;
+    options?: ArchbaseSecurityProps;
+}

package/dist/securityView/useSecurityEntityActions.d.ts

@@ -0,0 +1,32 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import { TranslateFn } from './columns';
+export interface SecurityEntityActionsParams<T> {
+    dataSource: IArchbaseDataSourceBase<T>;
+    /** Discriminador usado para saber qual modal abrir. */
+    securityType: string;
+    /** Fábrica do registro novo — {@code UserDto.newInstance()} e afins. */
+    newInstance: () => T;
+    /** Quando falso, o id do registro novo é apagado antes de inserir. */
+    createEntitiesWithId: boolean;
+    /**
+     * Chave da mensagem de confirmação de remoção, já com o artigo e o substantivo:
+     * {@code 'archbase:Deseja remover o usuário '}. O nome do registro é concatenado.
+     */
+    removeMessageKey: string;
+    setOpenedModal: (valor: string) => void;
+    setOpenedPermissionsModal: (valor: string) => void;
+    validationContext?: {
+        clearAll: () => void;
+    };
+    t: TranslateFn;
+}
+export interface SecurityEntityActions<T> {
+    handleAdd: () => void;
+    handleViewRow: (row: any) => void;
+    handleEditRow: (row: any) => void;
+    handleRemoveRow: (row: any) => void;
+    handleSaveModal: () => Promise<void>;
+    handleCancelModal: () => void;
+    handleOpenPermissionsModal: () => void;
+}
+export declare function useSecurityEntityActions<T>({ dataSource, securityType, newInstance, createEntitiesWithId, removeMessageKey, setOpenedModal, setOpenedPermissionsModal, validationContext, t, }: SecurityEntityActionsParams<T>): SecurityEntityActions<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/security-ui",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Security UI components for Archbase React - Forms, Modals, and Views",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -40,11 +40,11 @@
     "inversify-react": "^1.1.0",
     "rxjs": "^7.8.2",
     "uuid": "^9.0.1",
-    "@archbase/core": "4.1.0",
-    "@archbase/data": "4.1.0",
-    "@archbase/components": "4.1.0",
-    "@archbase/layout": "4.1.0",
-    "@archbase/security": "4.1.0"
+    "@archbase/core": "4.2.0",
+    "@archbase/data": "4.2.0",
+    "@archbase/components": "4.2.0",
+    "@archbase/layout": "4.2.0",
+    "@archbase/security": "4.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.0.6",