@adonis-agora/authkit-server 0.34.0

package/build/src/host/admin_api/admin_users_service.js

@@ -0,0 +1,308 @@
+import { randomBytes } from "node:crypto";
+import { supportsAccountDeletion, supportsAccountStatus, supportsProfile, supportsCountByGlobalRole, } from "../../accounts/account_store.js";
+import { sendPasswordResetEmail } from "../default_mailer.js";
+import { AccountDeletionService, } from "../account_deletion_service.js";
+import { PasswordPolicyError } from "../../password/password_manager.js";
+import { resolveEffectiveRolesCatalog } from "../runtime_toggles.js";
+/**
+ * Lógica de gestão de usuários compartilhada entre o console admin (B6, HTML) e a
+ * Admin REST API (R6, JSON). Encapsula o fluxo "create + invite", reset de senha,
+ * troca de status e atualização de perfil/roles — todos auditando com o `actor`
+ * informado (`admin-api` nas chamadas REST).
+ */
+export class AdminUsersService {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    /**
+     * Cria uma conta. Com `password`: já nasce com a senha. Sem `password` (ou
+     * `invite: true`): cria com senha aleatória forte e dispara o e-mail de reset
+     * (o usuário define a própria). Audita `user.created`.
+     */
+    async create(ctx, input, actor) {
+        const store = this.cfg.accountStore;
+        const existing = await store.findByEmail(input.email);
+        if (existing)
+            return { ok: false, reason: "email_taken" };
+        const hasPassword = !!input.password;
+        const initialPassword = input.password ?? randomBytes(24).toString("hex");
+        let account;
+        try {
+            account = await store.create({
+                email: input.email,
+                password: initialPassword,
+                fullName: input.name ?? null,
+            });
+        }
+        catch (error) {
+            // Política de senha aplicada também na criação por admin (quando há senha).
+            if (error instanceof PasswordPolicyError) {
+                return {
+                    ok: false,
+                    reason: "password_policy",
+                    messageKey: error.key,
+                    messageParams: error.params,
+                };
+            }
+            throw error;
+        }
+        await this.cfg.audit?.record({
+            type: "user.created",
+            accountId: account.id,
+            email: input.email,
+            actorId: actor.actorId,
+            ip: actor.ip,
+            metadata: {
+                invited: !hasPassword,
+                ...(actor.source ? { actor: actor.source } : {}),
+            },
+        });
+        if (!hasPassword) {
+            await this.sendResetEmail(ctx, account.email);
+        }
+        return { ok: true, account, invited: !hasPassword };
+    }
+    /** Emite token de reset + envia e-mail. Retorna a conta (ou null se inexistente). */
+    async resetPassword(ctx, accountId, actor) {
+        const account = await this.cfg.accountStore.findById(accountId);
+        if (!account)
+            return null;
+        await this.sendResetEmail(ctx, account.email);
+        await this.cfg.audit?.record({
+            type: "user.password_reset_sent",
+            accountId,
+            email: account.email,
+            actorId: actor.actorId,
+            ip: actor.ip,
+            ...(actor.source ? { metadata: { actor: actor.source } } : {}),
+        });
+        return account;
+    }
+    /**
+     * Habilita/desabilita uma conta. Retorna false quando o store não suporta a
+     * capacidade (o caller responde 409). Audita `user.disabled`/`user.enabled`.
+     */
+    async setStatus(accountId, disable, actor) {
+        const store = this.cfg.accountStore;
+        if (!supportsAccountStatus(store))
+            return false;
+        if (disable)
+            await store.disableAccount(accountId);
+        else
+            await store.enableAccount(accountId);
+        await this.cfg.audit?.record({
+            type: disable ? "user.disabled" : "user.enabled",
+            accountId,
+            actorId: actor.actorId,
+            ip: actor.ip,
+            ...(actor.source ? { metadata: { actor: actor.source } } : {}),
+        });
+        return true;
+    }
+    /**
+     * Substitui as roles globais de uma conta validando contra o catálogo runtime.
+     *
+     * Regras:
+     *   - Roles presentes no catálogo são aceitas.
+     *   - Roles que o usuário JÁ TEM mas que não estão no catálogo ("fora do catálogo")
+     *     podem ser REMOVIDAS (não incluir no array roles = remoção normal).
+     *   - Roles desconhecidas que não estão no catálogo E que o usuário não tinha
+     *     são REJEITADAS (retorna erro i18n).
+     *   - Quando settings não disponível, aceita tudo (fail-safe).
+     *
+     * @returns `null` quando OK; string i18n key quando há role inválida nova.
+     */
+    async setGlobalRolesValidated(accountId, roles, settings) {
+        if (settings) {
+            const catalog = await resolveEffectiveRolesCatalog(settings);
+            const catalogNames = new Set(catalog.roles.map((r) => r.name));
+            // Carrega as roles atuais do usuário para saber quais são "fora do catálogo".
+            const account = await this.cfg.accountStore.findById(accountId);
+            const currentRoles = new Set(account?.globalRoles ?? []);
+            // Roles que o usuário não tinha E que não estão no catálogo = inválidas.
+            for (const role of roles) {
+                if (!catalogNames.has(role) && !currentRoles.has(role)) {
+                    return "admin.roles.unknown_role";
+                }
+            }
+        }
+        await this.cfg.accountStore.setGlobalRoles(accountId, roles);
+        return null;
+    }
+    /** Substitui as roles globais de uma conta (normaliza nada — recebe array pronto). */
+    async setGlobalRoles(accountId, roles) {
+        await this.cfg.accountStore.setGlobalRoles(accountId, roles);
+    }
+    /** Roles globais que conferem acesso de admin (default ['ADMIN']). */
+    adminRoles() {
+        const roles = this.cfg.admin?.roles;
+        return roles && roles.length > 0 ? roles : ["ADMIN"];
+    }
+    /** Um conjunto de roles contém ao menos uma role de admin? */
+    hasAdminRole(roles) {
+        const adminRoles = new Set(this.adminRoles());
+        for (const r of roles) {
+            if (adminRoles.has(r))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Conta quantas contas possuem ao menos uma role de admin. Usado para a
+     * invariante de "último admin" — chamado apenas em mudanças de role.
+     *
+     * CAMINHO EFICIENTE: quando o store expõe `countByGlobalRole` E há exatamente
+     * UMA role de admin, conta direto no DB sem paginar a base. Com MÚLTIPLAS roles
+     * de admin NÃO usamos a capability: somar `countByGlobalRole` por role
+     * sobrecontaria contas que possuem 2+ roles de admin, e overcount aqui é uma
+     * regressão de SEGURANÇA (relaxaria o guard de last-admin). Nesse caso caímos
+     * no scan paginado, que deduplica naturalmente (conta cada conta uma vez).
+     *
+     * FALLBACK (sem capability ou múltiplas roles): pagina via `listAccounts`
+     * (store-agnóstico, não exige query SQL específica de dialeto sobre a coluna
+     * JSON `globalRoles`) e conta in-memory deduplicado.
+     */
+    async countAdmins() {
+        const store = this.cfg.accountStore;
+        const adminRoles = this.adminRoles();
+        // Caminho eficiente: capability presente + exatamente uma role de admin
+        // (evita double-count que sobrecontaria com múltiplas roles).
+        if (adminRoles.length === 1 && supportsCountByGlobalRole(store)) {
+            return store.countByGlobalRole(adminRoles[0]);
+        }
+        return this.countAdminsByScan();
+    }
+    /**
+     * Fallback de contagem por paginação de `listAccounts` (deduplicado: cada
+     * conta é contada no máximo uma vez via {@link hasAdminRole}).
+     *
+     * Terminadores honestos (sem número mágico): a paginação para quando
+     *   - a página veio incompleta (`data.length < pageSize`) → última página, OU
+     *   - a página veio vazia (`data.length === 0`) → sem mais dados, OU
+     *   - já cobrimos o total reportado (`page * pageSize >= total`).
+     * Uma página COMPLETA com `total` ainda maior continua paginando. Isto encerra
+     * de forma garantida para qualquer store que devolva páginas finitas (a última
+     * página é, por definição, menor que `pageSize` ou vazia).
+     */
+    async countAdminsByScan() {
+        const store = this.cfg.accountStore;
+        const pageSize = 100;
+        let page = 1;
+        let count = 0;
+        while (true) {
+            const { data, total } = await store.listAccounts({
+                page,
+                limit: pageSize,
+            });
+            for (const acc of data) {
+                if (this.hasAdminRole(acc.globalRoles ?? []))
+                    count++;
+            }
+            if (data.length < pageSize || page * pageSize >= total)
+                break;
+            page++;
+        }
+        return count;
+    }
+    /**
+     * Aplica proteções de segurança a uma troca de roles globais ANTES de gravar:
+     *
+     *   - `last_admin`: bloqueia remover a role de admin da ÚLTIMA conta que a possui
+     *     (evita lockout permanente do console). Só dispara quando o target ATUALMENTE
+     *     é admin, o novo conjunto NÃO é admin, e ele é o único admin.
+     *   - `cannot_self_demote`: bloqueia o ator remover a própria role de admin
+     *     (`actorId === targetId` e o novo conjunto não tem admin). Só aplica quando
+     *     há um `actorId` identificável.
+     *
+     * @returns código i18n/erro quando a operação deve ser bloqueada; `null` quando OK.
+     */
+    async guardGlobalRolesChange(targetId, newRoles, actorId) {
+        const target = await this.cfg.accountStore.findById(targetId);
+        const currentlyAdmin = this.hasAdminRole(target?.globalRoles ?? []);
+        const willBeAdmin = this.hasAdminRole(newRoles);
+        // Só há risco quando a operação REMOVE o status de admin de quem o tinha.
+        if (!currentlyAdmin || willBeAdmin)
+            return null;
+        // Auto-rebaixamento: o ator removendo a própria role de admin.
+        if (actorId && actorId === targetId)
+            return "cannot_self_demote";
+        // Último admin: se o target é o único admin, a remoção causaria lockout.
+        const admins = await this.countAdmins();
+        if (admins <= 1)
+            return "last_admin";
+        return null;
+    }
+    /** Atualiza nome/avatar (capacidade opcional). Retorna a conta ou null. */
+    async updateProfile(accountId, patch) {
+        const store = this.cfg.accountStore;
+        if (!supportsProfile(store))
+            return null;
+        return store.updateProfile(accountId, patch);
+    }
+    /**
+     * Deleta uma conta pelo admin, usando o MESMO cascade do self-service
+     * ({@link AccountDeletionService}). Precisa do {@link OidcService} (para revogar
+     * sessões/grants). Retorna `{ ok: false, reason }` se a conta não existe ou o
+     * store não suporta hard delete (o caller responde 404/409). Audita
+     * `account.deleted` (ator admin) dentro do cascade + `user.deleted` aqui (trilha
+     * administrativa).
+     */
+    async delete(oidc, accountId, actor, enqueue) {
+        const store = this.cfg.accountStore;
+        if (!supportsAccountDeletion(store))
+            return { ok: false, reason: "unsupported" };
+        const account = await store.findById(accountId);
+        if (!account)
+            return { ok: false, reason: "not_found" };
+        const source = actor.source === "admin" ? "admin" : "admin-api";
+        // Trilha administrativa ANTES do cascade — assim esta linha também é
+        // anonimizada na etapa de anonimização do audit (não reintroduz PII).
+        await this.cfg.audit?.record({
+            type: "user.deleted",
+            accountId,
+            email: account.email,
+            actorId: actor.actorId,
+            ip: actor.ip,
+            metadata: { actor: source },
+        });
+        // OPT-IN durável (admin/admin-api): enfileira o cascade COMPLETO (fully async).
+        if (this.cfg.accountLifecycle?.durable && enqueue) {
+            const runId = await enqueue({
+                accountId,
+                actor: { actorId: actor.actorId, ip: actor.ip, source },
+            });
+            return { ok: true, enqueued: true, runId };
+        }
+        // Caminho SÍNCRONO de sempre (byte-idêntico): cascade in-process.
+        const result = await new AccountDeletionService(oidc).delete(accountId, {
+            actorId: actor.actorId,
+            ip: actor.ip,
+            source,
+        });
+        return { ok: true, result };
+    }
+    /** Indica se a conta está desabilitada (false quando a capacidade não existe). */
+    async isDisabled(accountId) {
+        const store = this.cfg.accountStore;
+        return supportsAccountStatus(store) ? store.isDisabled(accountId) : false;
+    }
+    /** Emite o token de reset e dispara o e-mail (hook do config tem prioridade). */
+    async sendResetEmail(ctx, email) {
+        const issued = await this.cfg.accountStore.issuePasswordResetToken(email);
+        if (!issued)
+            return;
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const resetUrl = `${origin}/auth/reset-password?token=${encodeURIComponent(issued.token)}`;
+        if (this.cfg.mail?.onPasswordReset) {
+            await this.cfg.mail.onPasswordReset({
+                email,
+                resetUrl,
+                token: issued.token,
+            });
+        }
+        else {
+            await sendPasswordResetEmail(ctx, { email, resetUrl });
+        }
+    }
+}

package/build/src/host/admin_api/api_clients_controller.d.ts

@@ -0,0 +1,54 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Recurso de clients OIDC da Admin REST API (R6). Reaproveita o
+ * {@link AdminClientsService} (mesmo que o console B6). O secret é retornado UMA vez
+ * em create/regenerate. Audita create/update/delete.
+ */
+export default class ApiClientsController {
+    index(ctx: HttpContext): Promise<{
+        data: {
+            clientId: string;
+            confidential: boolean;
+            grants: string[];
+            redirectUris: string[];
+            postLogoutRedirectUris: string[];
+            tokenEndpointAuthMethod: string;
+            backchannelLogoutUri: string | null;
+            backchannelLogoutSessionRequired: boolean;
+        }[];
+        canList: boolean;
+    }>;
+    show(ctx: HttpContext): Promise<void | {
+        clientId: string;
+        confidential: boolean;
+        grants: string[];
+        redirectUris: string[];
+        postLogoutRedirectUris: string[];
+        tokenEndpointAuthMethod: string;
+        backchannelLogoutUri: string | null;
+        backchannelLogoutSessionRequired: boolean;
+    }>;
+    store(ctx: HttpContext): Promise<{
+        clientId: string;
+        clientSecret: string | null;
+    }>;
+    update(ctx: HttpContext): Promise<void | {
+        clientId: string;
+        confidential: boolean;
+        grants: string[];
+        redirectUris: string[];
+        postLogoutRedirectUris: string[];
+        tokenEndpointAuthMethod: string;
+        backchannelLogoutUri: string | null;
+        backchannelLogoutSessionRequired: boolean;
+    }>;
+    regenerateSecret(ctx: HttpContext): Promise<void | {
+        clientId: any;
+        clientSecret: string;
+    }>;
+    destroy(ctx: HttpContext): Promise<{
+        clientId: any;
+        deleted: boolean;
+    }>;
+}

package/build/src/host/admin_api/api_clients_controller.js

@@ -0,0 +1,89 @@
+import '../augmentations.js';
+import { AdminClientsService } from '../admin_clients_service.js';
+import { clientDto, createdClientDto, apiError } from './dto.js';
+import { clientInputValidator, clientCreateInput, clientPartialInput } from '../admin_validators.js';
+/** Resolve o serviço (== OidcService) + o AdminClientsService. */
+async function clientsService(ctx) {
+    const service = await ctx.containerResolver.make('authkit.server');
+    return { service, svc: new AdminClientsService(service) };
+}
+/**
+ * Recurso de clients OIDC da Admin REST API (R6). Reaproveita o
+ * {@link AdminClientsService} (mesmo que o console B6). O secret é retornado UMA vez
+ * em create/regenerate. Audita create/update/delete.
+ */
+export default class ApiClientsController {
+    async index(ctx) {
+        const { svc } = await clientsService(ctx);
+        if (!svc.canList) {
+            return { data: [], canList: false };
+        }
+        const clients = await svc.list();
+        return { data: clients.map(clientDto), canList: true };
+    }
+    async show(ctx) {
+        const { svc } = await clientsService(ctx);
+        const client = await svc.find(ctx.request.param('id'));
+        if (!client)
+            return ctx.response.notFound(apiError('not_found', 'Client não encontrado.'));
+        return clientDto(client);
+    }
+    async store(ctx) {
+        const { service, svc } = await clientsService(ctx);
+        const input = clientCreateInput(await ctx.request.validateUsing(clientInputValidator));
+        const created = await svc.create(input);
+        await service.config.audit?.record({
+            type: 'client.created',
+            clientId: created.clientId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { actor: 'admin-api' },
+        });
+        ctx.response.status(201);
+        return createdClientDto(created);
+    }
+    async update(ctx) {
+        const { service, svc } = await clientsService(ctx);
+        const id = ctx.request.param('id');
+        const existing = await svc.find(id);
+        if (!existing)
+            return ctx.response.notFound(apiError('not_found', 'Client não encontrado.'));
+        await svc.update(id, clientPartialInput(await ctx.request.validateUsing(clientInputValidator)));
+        await service.config.audit?.record({
+            type: 'client.updated',
+            clientId: id,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { actor: 'admin-api' },
+        });
+        const updated = await svc.find(id);
+        return clientDto(updated);
+    }
+    async regenerateSecret(ctx) {
+        const { service, svc } = await clientsService(ctx);
+        const id = ctx.request.param('id');
+        try {
+            const secret = await svc.regenerateSecret(id);
+            await service.config.audit?.record({
+                type: 'client.updated',
+                clientId: id,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { actor: 'admin-api', action: 'regenerate_secret' },
+            });
+            return { clientId: id, clientSecret: secret };
+        }
+        catch (e) {
+            return ctx.response.conflict(apiError('cannot_regenerate', e.message));
+        }
+    }
+    async destroy(ctx) {
+        const { service, svc } = await clientsService(ctx);
+        const id = ctx.request.param('id');
+        await svc.delete(id);
+        await service.config.audit?.record({
+            type: 'client.deleted',
+            clientId: id,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { actor: 'admin-api' },
+        });
+        return { clientId: id, deleted: true };
+    }
+}

package/build/src/host/admin_api/api_keys_controller.d.ts

@@ -0,0 +1,19 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Gestão da chave de assinatura managed via Admin REST API (Bearer).
+ * Sob `/api/authkit/v1/keys`. Retorna 501 (`not_implemented`) quando o jwks não é
+ * managed+store (sem keystore gerenciável). A rotação aplica ao vivo e audita
+ * (`keys.rotated`) dentro de `svc.rotateKeys`.
+ */
+export default class ApiKeysController {
+    /** GET /keys — status da chave de assinatura managed (idade + política + ETA). */
+    status(ctx: HttpContext): Promise<void | import("../key_rotation_actions.js").KeysStatus>;
+    /** POST /keys/rotate — { retire?, keep? } → rotaciona agora. */
+    rotate(ctx: HttpContext): Promise<void | {
+        rotated: true;
+        newKid: string;
+        retiredKids: string[];
+        keptKids: string[];
+    }>;
+}

package/build/src/host/admin_api/api_keys_controller.js

@@ -0,0 +1,36 @@
+import '../augmentations.js';
+import { buildKeysStatus, rotateNow } from '../key_rotation_actions.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { apiError } from './dto.js';
+/**
+ * Gestão da chave de assinatura managed via Admin REST API (Bearer).
+ * Sob `/api/authkit/v1/keys`. Retorna 501 (`not_implemented`) quando o jwks não é
+ * managed+store (sem keystore gerenciável). A rotação aplica ao vivo e audita
+ * (`keys.rotated`) dentro de `svc.rotateKeys`.
+ */
+export default class ApiKeysController {
+    /** GET /keys — status da chave de assinatura managed (idade + política + ETA). */
+    async status(ctx) {
+        const svc = await ctx.containerResolver.make('authkit.server');
+        // RuntimeSettings é opcional (tabela auth_settings ausente → política default).
+        const settings = await resolveRuntimeSettings(ctx);
+        const status = await buildKeysStatus(svc, settings);
+        if (!status) {
+            return ctx.response
+                .status(501)
+                .send(apiError('not_implemented', 'jwks não é managed+store.'));
+        }
+        return status;
+    }
+    /** POST /keys/rotate — { retire?, keep? } → rotaciona agora. */
+    async rotate(ctx) {
+        const svc = await ctx.containerResolver.make('authkit.server');
+        if (typeof svc.rotateKeys !== 'function' ||
+            (await svc.keystoreAgeDays?.().catch(() => null)) === null) {
+            return ctx.response
+                .status(501)
+                .send(apiError('not_implemented', 'rotação indisponível (jwks não é managed+store).'));
+        }
+        return rotateNow(svc, ctx.request.body());
+    }
+}

package/build/src/host/admin_api/api_misc_controller.d.ts

@@ -0,0 +1,19 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Endpoints utilitários da Admin REST API: log de auditoria (`GET /audit`) e
+ * introspecção genérica de token (`POST /tokens/verify`).
+ */
+export default class ApiMiscController {
+    /** GET /audit — listagem paginada (501 JSON quando o sink não consulta). */
+    audit(ctx: HttpContext): Promise<void | {
+        data: any;
+        total: any;
+        page: number;
+        limit: number;
+    }>;
+    /** GET /stats — métricas-resumo do IdP (totais + MAU + séries de 30 dias). */
+    stats(ctx: HttpContext): Promise<import("../admin_stats_service.js").AdminStats>;
+    /** POST /tokens/verify — { token } → resultado de introspecção (PAT ou opaque AT). */
+    verify(ctx: HttpContext): Promise<import("./token_verify_service.js").VerifyResult>;
+}

package/build/src/host/admin_api/api_misc_controller.js

@@ -0,0 +1,44 @@
+import '../augmentations.js';
+import { TokenVerifyService } from './token_verify_service.js';
+import { AdminSessionsService } from '../admin_sessions_service.js';
+import { computeAdminStats } from '../admin_stats_service.js';
+import { auditDto, apiError } from './dto.js';
+import { tokenVerifyValidator } from '../admin_validators.js';
+/**
+ * Endpoints utilitários da Admin REST API: log de auditoria (`GET /audit`) e
+ * introspecção genérica de token (`POST /tokens/verify`).
+ */
+export default class ApiMiscController {
+    /** GET /audit — listagem paginada (501 JSON quando o sink não consulta). */
+    async audit(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const sink = cfg.audit;
+        if (!sink || typeof sink.list !== 'function') {
+            return ctx.response
+                .status(501)
+                .send(apiError('not_implemented', 'O sink de auditoria configurado não suporta consulta.'));
+        }
+        const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
+        const limit = Math.max(1, Math.min(100, Number.parseInt(ctx.request.input('limit', '20'), 10) || 20));
+        const type = ctx.request.input('type')?.trim() || undefined;
+        const subject = ctx.request.input('subject')?.trim() || undefined;
+        const result = await sink.list({ page, limit, type, subject });
+        return { data: result.data.map(auditDto), total: result.total, page, limit };
+    }
+    /** GET /stats — métricas-resumo do IdP (totais + MAU + séries de 30 dias). */
+    async stats(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const sessions = new AdminSessionsService(service);
+        return computeAdminStats(cfg, sessions);
+    }
+    /** POST /tokens/verify — { token } → resultado de introspecção (PAT ou opaque AT). */
+    async verify(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const { token } = await ctx.request.validateUsing(tokenVerifyValidator);
+        const verifier = new TokenVerifyService(cfg, service.provider);
+        return verifier.verify(token);
+    }
+}

package/build/src/host/admin_api/api_orgs_controller.d.ts

@@ -0,0 +1,108 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * CRUD de organizações da Admin REST API.
+ * Todas as rotas ficam sob `/api/authkit/v1/organizations`.
+ */
+export default class ApiOrgsController {
+    /** GET /organizations — lista todas as orgs com contagem de membros. */
+    index(ctx: HttpContext): Promise<void | {
+        data: {
+            memberCount?: number | undefined;
+            id: string;
+            name: string;
+            slug: string;
+            logoUrl: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: string;
+        }[];
+    }>;
+    /** POST /organizations — cria uma org. Body: { name, slug, ownerAccountId, logoUrl? } */
+    store(ctx: HttpContext): Promise<void | {
+        memberCount?: number | undefined;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+    }>;
+    /** GET /organizations/:id — obtém uma org com membros e convites. */
+    show(ctx: HttpContext): Promise<void | {
+        members: {
+            accountId: string;
+            email: string | null;
+            role: string;
+            joinedAt: string;
+        }[];
+        pendingInvitations: {
+            id: string;
+            organizationId: string;
+            email: string;
+            role: string;
+            invitedBy: string;
+            expiresAt: string;
+            acceptedAt: string | null;
+            createdAt: string;
+        }[];
+        memberCount?: number | undefined;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+    }>;
+    /** PATCH /organizations/:id — atualiza nome e/ou logo. */
+    update(ctx: HttpContext): Promise<void | {
+        memberCount?: number | undefined;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: string;
+    }>;
+    /** DELETE /organizations/:id */
+    destroy(ctx: HttpContext): Promise<void | {
+        id: any;
+        deleted: boolean;
+    }>;
+    /** POST /organizations/:id/members — adiciona membro. Body: { accountId, role } */
+    addMember(ctx: HttpContext): Promise<void | {
+        orgId: any;
+        accountId: string;
+        role: string | undefined;
+        added: boolean;
+    }>;
+    /** DELETE /organizations/:id/members/:accountId */
+    removeMember(ctx: HttpContext): Promise<void | {
+        orgId: any;
+        accountId: any;
+        removed: boolean;
+    }>;
+    /** PATCH /organizations/:id/members/:accountId — troca o papel. Body: { role } */
+    updateMemberRole(ctx: HttpContext): Promise<void | {
+        orgId: any;
+        accountId: any;
+        role: string;
+        updated: boolean;
+    }>;
+    /** POST /organizations/:id/invitations — cria convite. Body: { email, role } */
+    createInvitation(ctx: HttpContext): Promise<void | {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: string;
+        invitedBy: string;
+        expiresAt: string;
+        acceptedAt: string | null;
+        createdAt: string;
+    }>;
+    /** DELETE /organizations/:id/invitations/:invitationId */
+    revokeInvitation(ctx: HttpContext): Promise<void | {
+        orgId: any;
+        invitationId: any;
+        revoked: boolean;
+    }>;
+}