export declare enum TipoRecurso {
    VIEW = "VIEW",
    API = "API"
}
export declare class AccessScheduleDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    description: string;
    intervals: AccessIntervalDto[];
    constructor(data: any);
    static newInstance: () => AccessScheduleDto;
}
export declare class AccessIntervalDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    accessSchedule?: AccessScheduleDto;
    dayOfWeek: number;
    startTime: string;
    endTime: string;
    constructor(data: any);
    static newInstance: () => AccessIntervalDto;
}
export declare abstract class SecurityDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    name: string;
    description: string;
    actions: ActionDto[];
    constructor(data: any);
}
export declare class ActionDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    name: string;
    description: string;
    resource?: ResourceDto;
    category: string;
    active: boolean;
    actionVersion: string;
    isNewAction: boolean;
    constructor(data: any);
    static newInstance: () => ActionDto;
}
export declare class ProfileDto extends SecurityDto {
    type: string;
    isNewProfile: boolean;
    constructor(data: any);
    static newInstance: () => ProfileDto;
}
export declare class UserGroupDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    group?: GroupDto;
    constructor(data: any);
    static newInstance: (group: GroupDto) => UserGroupDto;
}
export declare class GroupDto extends SecurityDto {
    type: string;
    isNewGroup: boolean;
    constructor(data: any);
    static newInstance: () => GroupDto;
}
export declare class ResourceDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    name: string;
    description: string;
    actions: ActionDto[];
    active: boolean;
    type: TipoRecurso;
    isNewResource: boolean;
    constructor(data: any);
    static newInstance: () => ResourceDto;
}
export declare class UserDto extends SecurityDto {
    userName: string;
    password: string;
    changePasswordOnNextLogin: boolean;
    allowPasswordChange: boolean;
    allowMultipleLogins: boolean;
    passwordNeverExpires: boolean;
    /**
     * Data da última troca de senha, preenchida pelo backend. Base de cálculo da expiração
     * periódica quando `archbase.security.password.expiration-days` está configurado.
     * Somente leitura — o backend a atualiza sozinho a cada troca de senha.
     */
    passwordChangedAt?: string;
    accountDeactivated: boolean;
    accountLocked: boolean;
    unlimitedAccessHours: boolean;
    isAdministrator: boolean;
    accessSchedule?: AccessScheduleDto;
    groups: UserGroupDto[];
    profile?: ProfileDto;
    avatar?: string;
    nickname: string;
    email?: string;
    type: string;
    isNewUser: boolean;
    /**
     * Matrícula do funcionário na empresa: o número pelo qual o RH e a folha identificam a pessoa,
     * e que costuma ser o elo com ponto, crachá e folha de pagamento.
     *
     * Opcional de propósito — contas de serviço e usuários que não são funcionários não têm uma.
     * Não é única: bases herdadas de sistemas antigos costumam ter matrícula repetida, e quem
     * precisar exigir unicidade cria o índice decidindo o escopo (global ou por tenant).
     *
     * Não confundir com {@link externalId}, que identifica a conta num provedor de identidade
     * (Keycloak, LDAP). Uma é o vínculo empregatício, a outra é a credencial — convivem.
     *
     * Requer archbase-security 3.1.20 ou superior no backend.
     */
    employeeId?: string;
    /**
     * ID da conta num provedor de identidade externo (Keycloak, LDAP e afins).
     *
     * Existe no backend desde antes da matrícula, mas nunca esteve neste DTO — então a tela lia e
     * devolvia o usuário sem ele. Declarado aqui para que o valor sobreviva a uma edição, junto com
     * a correção do lado do servidor que passou a gravá-lo.
     */
    externalId?: string;
    constructor(data: any);
    static newInstance: () => UserDto;
}
export declare class PermissionDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    security?: SecurityDto;
    action?: ActionDto;
    tenantId: string;
    companyId: string;
    projectId: string;
    constructor(data: any);
    static createDtoFromJson(data: any): SecurityDto;
    static newInstance: () => PermissionDto;
}
export declare class ApiTokenDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    tenantId: string;
    name: string;
    description: string;
    token: string;
    user: UserDto;
    expirationDate: string;
    revoked: boolean;
    activated: boolean;
    isNovoToken: boolean;
    constructor(data: any);
    static newInstance: () => ApiTokenDto;
}
export declare class AccessTokenDto {
    id: string;
    code: string;
    version: number;
    createEntityDate: string;
    updateEntityDate: string;
    createdByUser: string;
    lastModifiedByUser: string;
    token: string;
    tokenType: string;
    revoked: boolean;
    expired: boolean;
    expirationTime: number;
    expirationDate: string;
    user: UserDto;
    isNewAccessToken: boolean;
    constructor(data: any);
    static newInstance: () => AccessTokenDto;
}
export interface GrantPermissionDto {
    securityId: string;
    actionId: string;
    type: string;
}
export interface PermissionWithTypesDto {
    /**
     * A concessão a remover — **ausente quando a capacidade chega por herança**.
     *
     * Sem ela não há o que apagar: a permissão é do grupo ou do perfil, e removê-la a partir da tela
     * de uma pessoa tiraria o acesso de todo mundo. A interface precisa **dizer isso**; apenas
     * desabilitar o botão faz quem administra clicar sem entender por que nada acontece.
     */
    permissionId?: string;
    actionId: string;
    /**
     * O identificador estável da capacidade — `aprovar_custo`.
     *
     * Opcional porque backends anteriores a 3.4 não o enviam. Quando faltar, só a descrição está
     * disponível, e é ela que a tela mostra — o comportamento de antes.
     */
    actionName?: string;
    /**
     * O rótulo curto — "Aprovar custo".
     *
     * Ausente quando a capacidade não tem rótulo, que é o caso de todo catálogo existente. A tela
     * mostra `actionLabel ?? actionDescription`: enquanto ninguém declarar rótulo, ela exibe
     * exatamente o que exibe hoje.
     */
    actionLabel?: string;
    actionDescription: string;
    /**
     * O agrupamento dentro do recurso — "Custos".
     *
     * Substitui o `->` que era embutido na descrição e que o cliente quebrava na exibição para
     * simular hierarquia. Ausente quando não há.
     */
    actionCategory?: string;
    types?: string[];
    /**
     * As capacidades que esta declara precisar — **apenas as diretas**, em texto `recurso:acao`.
     *
     * Vêm junto do catálogo porque a tela precisa delas no momento da concessão: é o que permite
     * oferecer as dependências junto e avisar ao revogar. O fecho transitivo não vem aqui — para ele
     * existe `getCapabilityDependencies`.
     *
     * Ausente quando não há nenhuma, e em backends anteriores a 3.4.
     */
    requires?: string[];
}
/** Uma capacidade alcançada pelo fecho de dependências, e por onde se chegou nela. */
export interface CapabilityDependencyNodeDto {
    capability: string;
    /** Nulo quando a capacidade **não existe** no catálogo — estado legítimo, não erro. */
    actionId?: string | null;
    resourceName?: string;
    actionName?: string;
    actionDescription?: string;
    /** 1 para as diretas, 2 para as dependências das diretas, e assim por diante. */
    depth: number;
    /** A capacidade do nível anterior — o caminho até aqui. */
    requiredBy?: string;
    resolved: boolean;
}
/** Tudo de que uma capacidade depende, direta e indiretamente. */
export interface CapabilityDependencyTreeDto {
    actionId: string;
    capability: string;
    dependencies: CapabilityDependencyNodeDto[];
    /** `true` quando o teto de profundidade foi atingido e há dependências não exploradas. */
    truncated: boolean;
}
export interface ResoucePermissionsWithTypeDto {
    resourceId: string;
    /** O identificador estável do recurso — `tms.ordemservico`. Ausente em backends < 3.4. */
    resourceName?: string;
    resourceDescription: string;
    /**
     * `VIEW` para recurso registrado por uma tela, `API` para o que a varredura do `@HasPermission`
     * cadastrou.
     *
     * Ausente em backends anteriores a 3.4, e **nulo** para recurso criado antes de a coluna
     * existir. Nos dois casos a tela agrupa como "sem classificação", em vez de empurrar para um dos
     * baldes e mentir sobre o que aquilo é.
     */
    resourceType?: TipoRecurso | null;
    /**
     * Se o recurso está ativo.
     *
     * A lista **não** filtra por isto. Uma capacidade sobre ação ativa de recurso inativo é concedível
     * hoje e funciona hoje no `@HasPermission`, que não consulta `active` — e deixará de funcionar
     * quando `archbase.security.permission.require-active` for ligado. Escondê-la tiraria do admin a
     * chance de arrumar antes; então ela aparece, marcada.
     *
     * Ausente em backends que ainda não enviam o campo; a tela trata ausente como ativo.
     */
    resourceActive?: boolean;
    permissions: PermissionWithTypesDto[];
}
export interface ResouceActionPermissionDto {
    resourceId: string;
    resourceName?: string;
    resourceDescription: string;
    resourceType?: TipoRecurso | null;
    permissionId: string;
    actionId: string;
    actionName?: string;
    actionLabel?: string;
    actionDescription: string;
    actionCategory?: string;
}
export interface SimpleActionDto {
    actionName: string;
    actionDescription: string;
    /**
     * O rótulo curto, distinto da descrição que explica a ação.
     *
     * Ausente significa "use a descrição" — o comportamento de todo cliente anterior. É semeado
     * apenas quando a capacidade ainda não tem rótulo: quem já tem não é sobrescrito, para o texto
     * não oscilar entre duas telas que registram a mesma ação.
     */
    actionLabel?: string;
    /** O agrupamento dentro do recurso. Mesma regra de semeadura do rótulo. */
    actionCategory?: string;
    requires?: string[];
}
export interface SimpleResourceDto {
    resourceName: string;
    resourceDescription: string;
}
export interface ResourceRegisterDto {
    resource: SimpleResourceDto;
    actions: SimpleActionDto[];
}
export interface ResourcePermissionsDto {
    resourceName: string;
    permissions: string[];
}
/**
 * Tudo que o usuário autenticado alcança, agrupado por recurso.
 *
 * Devolvido por `GET /api/v1/resource/my-permissions`, disponível a partir do
 * archbase-security 3.2.3. Em backend anterior o caminho não existe — ver
 * `ArchbaseResourceService.findLoggedUserPermissions`.
 */
export interface LoggedUserPermissionsDto {
    /** Administrador não depende do catálogo; sem este campo um mapa vazio seria lido como "não pode nada". */
    administrator: boolean;
    /** Nome do recurso para os nomes das ações concedidas nele. */
    permissions: Record<string, string[]>;
}