@adonis-agora/authkit-server 0.34.0

package/build/src/host/account_lockout.d.ts

@@ -0,0 +1,86 @@
+import type { AuditSink } from '../audit/audit_sink.js';
+import type { ResolvedLockoutConfig } from '../define_config.js';
+/**
+ * Bloqueio progressivo de conta (anti-brute-force keyed por EMAIL, não por IP).
+ *
+ * Construído sobre o `@adonisjs/limiter` do HOST (peer/opt-in), exatamente como o
+ * `rate_limit.ts`: o service do limiter é importado de forma preguiçosa e fail-safe.
+ * Se o `@adonisjs/limiter` não estiver instalado/configurado, TODOS os métodos viram
+ * no-op (lockout desligado) e `isLocked` devolve `{ locked: false }` — NUNCA lança no
+ * caminho da request, e NÃO há migração/DB envolvido (usa o store do limiter do host).
+ *
+ * Esquema de chaves (todas namespaced + email normalizado):
+ * - `authkit_lockout_fail:{email}` — contador de falhas dentro da janela deslizante.
+ * - `authkit_lockout:{email}`      — chave bloqueada (TTL = duração progressiva do lock).
+ * - `authkit_lockout_count:{email}`— quantos locks já ocorreram (alimenta o backoff).
+ */
+/** Service do `@adonisjs/limiter` resolvido preguiçosamente. `any` de propósito (peer/opt-in). */
+type LimiterService = any;
+/**
+ * Permite reapontar/limpar o loader do limiter (usado em testes).
+ * @internal
+ */
+export declare function __setLockoutLimiterLoaderForTests(fn: (() => Promise<LimiterService | null>) | undefined): void;
+/**
+ * Backoff progressivo PURO (sem I/O — fácil de testar): a duração do lock cresce
+ * com o número de locks já ocorridos para a chave: `base * 2^(lockCount-1)`,
+ * limitada a `maxLockoutSec`. `lockCount` é 1-based (1 = primeiro lock).
+ */
+export declare function computeLockoutSec(lockCount: number, cfg: ResolvedLockoutConfig): number;
+/** Resultado de uma checagem de bloqueio. */
+export interface LockState {
+    locked: boolean;
+    /** Segundos até a conta destravar (presente quando `locked`). */
+    retryAfterSec?: number;
+}
+/** Contexto opcional de auditoria para o evento `account.locked`. */
+export interface LockoutAuditContext {
+    sink?: AuditSink;
+    ip?: string | null;
+}
+/**
+ * Helper de lockout amarrado a uma config resolvida. Cada método é fail-safe:
+ * resolve o limiter preguiçosamente e degrada para no-op quando ele está ausente
+ * ou quando `cfg.enabled === false`.
+ */
+export declare class AccountLockout {
+    private cfg;
+    constructor(cfg: ResolvedLockoutConfig);
+    private failKey;
+    private lockKey;
+    private countKey;
+    /**
+     * Resolve o limiter (ou `null`). Retorna `null` também quando lockout está
+     * desligado por config — assim o caminho de no-op é o mesmo.
+     */
+    private limiter;
+    /** Store de contagem de falhas (janela deslizante de `windowSec`). */
+    private failStore;
+    /**
+     * Store da contagem de locks. A janela é longa (mantém o histórico de locks por
+     * um tempo para o backoff progressivo crescer entre locks sucessivos).
+     */
+    private countStore;
+    /**
+     * Store dedicado a marcar a chave como bloqueada. `requests: 1` + `block(...)`
+     * com a duração progressiva; `isBlocked`/`availableIn` consultam o estado.
+     */
+    private lockStore;
+    /** `true`/retryAfter quando a conta está bloqueada. Fail-safe: `{ locked: false }`. */
+    isLocked(email: string): Promise<LockState>;
+    /**
+     * Registra uma falha de login. Ao cruzar `maxAttempts` dentro da janela, marca
+     * a chave como bloqueada com TTL progressivo e incrementa a contagem de locks.
+     * Emite `account.locked` UMA vez (na transição), não a cada tentativa bloqueada.
+     */
+    recordFailure(email: string, audit?: LockoutAuditContext): Promise<void>;
+    /**
+     * Limpa o estado de falhas após um login bem-sucedido. Remove o contador de
+     * falhas e o lock; mantém a contagem de locks (histórico para o backoff) — ela
+     * expira naturalmente pela janela longa do `countStore`.
+     */
+    clearFailures(email: string): Promise<void>;
+}
+/** Fabrica o helper de lockout a partir da config resolvida. */
+export declare function createAccountLockout(cfg: ResolvedLockoutConfig): AccountLockout;
+export {};

package/build/src/host/account_lockout.js

@@ -0,0 +1,185 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+let limiterServicePromise;
+/**
+ * Importa o service do limiter do HOST de forma preguiçosa e fail-safe (mesmo
+ * padrão de `rate_limit.ts`). Resolve `null` quando o limiter não está disponível.
+ */
+async function loadLimiter() {
+    if (!limiterServicePromise) {
+        const specifier = '@adonisjs/limiter/services/main';
+        limiterServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod.default ?? null)
+            .catch(() => null);
+    }
+    return limiterServicePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do limiter (usado em testes).
+ * @internal
+ */
+export function __setLockoutLimiterLoaderForTests(fn) {
+    if (fn) {
+        limiterServicePromise = fn();
+    }
+    else {
+        limiterServicePromise = undefined;
+    }
+}
+/** Normaliza o email para virar chave estável (lowercase + trim). */
+function normalizeEmail(email) {
+    return (email ?? '').trim().toLowerCase();
+}
+/**
+ * Backoff progressivo PURO (sem I/O — fácil de testar): a duração do lock cresce
+ * com o número de locks já ocorridos para a chave: `base * 2^(lockCount-1)`,
+ * limitada a `maxLockoutSec`. `lockCount` é 1-based (1 = primeiro lock).
+ */
+export function computeLockoutSec(lockCount, cfg) {
+    const n = Math.max(1, lockCount);
+    const grown = cfg.baseLockoutSec * 2 ** (n - 1);
+    return Math.min(grown, cfg.maxLockoutSec);
+}
+/**
+ * Helper de lockout amarrado a uma config resolvida. Cada método é fail-safe:
+ * resolve o limiter preguiçosamente e degrada para no-op quando ele está ausente
+ * ou quando `cfg.enabled === false`.
+ */
+export class AccountLockout {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    failKey(email) {
+        return `authkit_lockout_fail:${email}`;
+    }
+    lockKey(email) {
+        return `authkit_lockout:${email}`;
+    }
+    countKey(email) {
+        return `authkit_lockout_count:${email}`;
+    }
+    /**
+     * Resolve o limiter (ou `null`). Retorna `null` também quando lockout está
+     * desligado por config — assim o caminho de no-op é o mesmo.
+     */
+    async limiter() {
+        if (!this.cfg.enabled)
+            return null;
+        return loadLimiter();
+    }
+    /** Store de contagem de falhas (janela deslizante de `windowSec`). */
+    failStore(limiter) {
+        const opts = { requests: this.cfg.maxAttempts, duration: this.cfg.windowSec };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /**
+     * Store da contagem de locks. A janela é longa (mantém o histórico de locks por
+     * um tempo para o backoff progressivo crescer entre locks sucessivos).
+     */
+    countStore(limiter) {
+        const opts = { requests: 1_000_000, duration: this.cfg.maxLockoutSec * 4 };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /**
+     * Store dedicado a marcar a chave como bloqueada. `requests: 1` + `block(...)`
+     * com a duração progressiva; `isBlocked`/`availableIn` consultam o estado.
+     */
+    lockStore(limiter) {
+        const opts = { requests: 1, duration: this.cfg.maxLockoutSec };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /** `true`/retryAfter quando a conta está bloqueada. Fail-safe: `{ locked: false }`. */
+    async isLocked(email) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return { locked: false };
+        const limiter = await this.limiter();
+        if (!limiter)
+            return { locked: false };
+        try {
+            const store = this.lockStore(limiter);
+            const blocked = await store.isBlocked(this.lockKey(key));
+            if (!blocked)
+                return { locked: false };
+            const retryAfterSec = await store.availableIn(this.lockKey(key));
+            return { locked: true, retryAfterSec };
+        }
+        catch {
+            // Falha do limiter NUNCA derruba o login — degrada para "não bloqueado".
+            return { locked: false };
+        }
+    }
+    /**
+     * Registra uma falha de login. Ao cruzar `maxAttempts` dentro da janela, marca
+     * a chave como bloqueada com TTL progressivo e incrementa a contagem de locks.
+     * Emite `account.locked` UMA vez (na transição), não a cada tentativa bloqueada.
+     */
+    async recordFailure(email, audit) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return;
+        const limiter = await this.limiter();
+        if (!limiter)
+            return;
+        try {
+            // Se já está bloqueada, não conta de novo nem reemite o evento.
+            const lockStore = this.lockStore(limiter);
+            if (await lockStore.isBlocked(this.lockKey(key)))
+                return;
+            const failStore = this.failStore(limiter);
+            const res = await failStore.increment(this.failKey(key));
+            // `consumed` = falhas acumuladas na janela. Bloqueia ao atingir o teto.
+            const consumed = res?.consumed ?? 0;
+            if (consumed < this.cfg.maxAttempts)
+                return;
+            // Transição para bloqueado: incrementa a contagem de locks e calcula o TTL.
+            const countStore = this.countStore(limiter);
+            const countRes = await countStore.increment(this.countKey(key));
+            const lockCount = countRes?.consumed ?? 1;
+            const lockoutSec = computeLockoutSec(lockCount, this.cfg);
+            await lockStore.block(this.lockKey(key), lockoutSec);
+            // Zera o contador de falhas (a contagem recomeça após o lock).
+            await failStore.delete(this.failKey(key));
+            await audit?.sink?.record({
+                type: 'account.locked',
+                email: key,
+                ip: audit?.ip ?? null,
+                metadata: { lockCount, lockoutSec },
+            });
+        }
+        catch {
+            // Best-effort: nunca propaga erro do limiter para o caminho da request.
+        }
+    }
+    /**
+     * Limpa o estado de falhas após um login bem-sucedido. Remove o contador de
+     * falhas e o lock; mantém a contagem de locks (histórico para o backoff) — ela
+     * expira naturalmente pela janela longa do `countStore`.
+     */
+    async clearFailures(email) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return;
+        const limiter = await this.limiter();
+        if (!limiter)
+            return;
+        try {
+            await this.failStore(limiter).delete(this.failKey(key));
+            await this.lockStore(limiter).delete(this.lockKey(key));
+        }
+        catch {
+            // no-op fail-safe
+        }
+    }
+}
+/** Fabrica o helper de lockout a partir da config resolvida. */
+export function createAccountLockout(cfg) {
+    return new AccountLockout(cfg);
+}

package/build/src/host/active_org_cookie.d.ts

@@ -0,0 +1,28 @@
+import type { ActiveOrgInfo } from '../accounts/account_store.js';
+/** Nome do cookie da org ativa. HttpOnly, SameSite=Lax, Secure em prod. */
+export declare const ACTIVE_ORG_COOKIE = "authkit_active_org";
+/** TTL máximo do cookie da org ativa (30 dias em segundos). */
+export declare const ACTIVE_ORG_COOKIE_TTL: number;
+/**
+ * Codifica as informações da org ativa num valor de cookie (plaintext, sem
+ * assinatura — a assinatura fica a cargo do jar de cookies do AdonisJS/Keygrip
+ * via o próprio cookie signed). Formato: `orgId\torgSlug\torgRole`.
+ * TAB é escolhido pois IDs e slugs não o contêm.
+ */
+export declare function encodeActiveOrgCookie(info: ActiveOrgInfo): string;
+/**
+ * Decodifica o valor cru do cookie. Retorna `null` se o formato for inválido.
+ * Não valida assinatura — assume que o caller já verificou (AdonisJS request.cookiesList).
+ */
+export declare function decodeActiveOrgCookie(value: string | null | undefined): ActiveOrgInfo | null;
+/**
+ * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
+ * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
+ * (o oidc-provider não assina cookies da aplicação; apenas verifica os seus). A
+ * validação de assinatura para este cookie de aplicação é feita no controller AdonisJS
+ * ao gravar (via `ctx.response.cookie` com `signed: true`). Aqui fazemos best-effort:
+ * se o valor estiver presente e parseable, usamos; caso contrário retorna null.
+ *
+ * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
+ */
+export declare function readActiveOrgFromKoaCtx(koaCtx: any): ActiveOrgInfo | null;

package/build/src/host/active_org_cookie.js

@@ -0,0 +1,47 @@
+/** Nome do cookie da org ativa. HttpOnly, SameSite=Lax, Secure em prod. */
+export const ACTIVE_ORG_COOKIE = 'authkit_active_org';
+/** TTL máximo do cookie da org ativa (30 dias em segundos). */
+export const ACTIVE_ORG_COOKIE_TTL = 60 * 60 * 24 * 30;
+/**
+ * Codifica as informações da org ativa num valor de cookie (plaintext, sem
+ * assinatura — a assinatura fica a cargo do jar de cookies do AdonisJS/Keygrip
+ * via o próprio cookie signed). Formato: `orgId\torgSlug\torgRole`.
+ * TAB é escolhido pois IDs e slugs não o contêm.
+ */
+export function encodeActiveOrgCookie(info) {
+    return `${info.orgId}\t${info.orgSlug}\t${info.orgRole}`;
+}
+/**
+ * Decodifica o valor cru do cookie. Retorna `null` se o formato for inválido.
+ * Não valida assinatura — assume que o caller já verificou (AdonisJS request.cookiesList).
+ */
+export function decodeActiveOrgCookie(value) {
+    if (!value)
+        return null;
+    const parts = value.split('\t');
+    if (parts.length !== 3)
+        return null;
+    const [orgId, orgSlug, orgRole] = parts;
+    if (!orgId || !orgSlug || !orgRole)
+        return null;
+    return { orgId, orgSlug, orgRole };
+}
+/**
+ * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
+ * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
+ * (o oidc-provider não assina cookies da aplicação; apenas verifica os seus). A
+ * validação de assinatura para este cookie de aplicação é feita no controller AdonisJS
+ * ao gravar (via `ctx.response.cookie` com `signed: true`). Aqui fazemos best-effort:
+ * se o valor estiver presente e parseable, usamos; caso contrário retorna null.
+ *
+ * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
+ */
+export function readActiveOrgFromKoaCtx(koaCtx) {
+    try {
+        const raw = koaCtx?.cookies?.get?.(ACTIVE_ORG_COOKIE, { signed: false });
+        return decodeActiveOrgCookie(raw);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Identificador NÃO-SENSÍVEL e estável da API key que autenticou a request, para
+ * trilha de auditoria (M9). Deriva de um SHA-256 da key e expõe só um prefixo
+ * curto do hash — NUNCA a key em si nem qualquer pedaço dela. Estável entre
+ * requests (mesma key → mesmo id), permitindo saber QUAL key agiu sem vazar o
+ * segredo. Formato: `admin-key:<8 hex>`.
+ */
+export declare function adminKeyId(key: string): string;
+/**
+ * Guard da Admin REST API (R6). Espelha o `adminGuard` do console (B6):
+ *   0. `config.adminApi.enabled` desligado → 404 (não vaza a existência da API);
+ *   1. `Authorization: Bearer <key>` ausente/inválido → 401 JSON.
+ * Sem nenhuma API key configurada, qualquer request é 401 (fail-safe). As respostas
+ * de erro seguem o envelope `{ error: { code, message } }`.
+ */
+export declare const adminApiGuard: (ctx: any, next: () => Promise<void>) => Promise<any>;

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

@@ -0,0 +1,59 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+/**
+ * Identificador NÃO-SENSÍVEL e estável da API key que autenticou a request, para
+ * trilha de auditoria (M9). Deriva de um SHA-256 da key e expõe só um prefixo
+ * curto do hash — NUNCA a key em si nem qualquer pedaço dela. Estável entre
+ * requests (mesma key → mesmo id), permitindo saber QUAL key agiu sem vazar o
+ * segredo. Formato: `admin-key:<8 hex>`.
+ */
+export function adminKeyId(key) {
+    const digest = createHash('sha256').update(key).digest('hex').slice(0, 8);
+    return `admin-key:${digest}`;
+}
+/**
+ * Compara o Bearer recebido contra a lista de API keys em tempo constante. Cada
+ * comparação só roda quando os comprimentos batem (o `timingSafeEqual` lança em
+ * tamanhos diferentes); o curto-circuito por comprimento NÃO vaza a key (só o seu
+ * tamanho), aceitável para um segredo de alta entropia gerado pelo operador.
+ *
+ * Retorna a key que casou (para derivar o id de auditoria) ou `null`. A varredura
+ * NÃO faz short-circuit no primeiro match — mantém o tempo independente de QUAL
+ * key casou.
+ */
+function matchKey(header, keys) {
+    if (!header || !header.startsWith('Bearer '))
+        return null;
+    const provided = Buffer.from(header.slice(7));
+    let matched = null;
+    for (const key of keys) {
+        const expected = Buffer.from(key);
+        if (provided.length === expected.length && timingSafeEqual(provided, expected)) {
+            matched = key;
+        }
+    }
+    return matched;
+}
+/**
+ * Guard da Admin REST API (R6). Espelha o `adminGuard` do console (B6):
+ *   0. `config.adminApi.enabled` desligado → 404 (não vaza a existência da API);
+ *   1. `Authorization: Bearer <key>` ausente/inválido → 401 JSON.
+ * Sem nenhuma API key configurada, qualquer request é 401 (fail-safe). As respostas
+ * de erro seguem o envelope `{ error: { code, message } }`.
+ */
+export const adminApiGuard = async (ctx, next) => {
+    const service = await ctx.containerResolver.make('authkit.server');
+    const cfg = service.config;
+    if (!cfg.adminApi.enabled) {
+        return ctx.response.notFound();
+    }
+    const keys = cfg.adminApi.apiKeys;
+    const matched = keys.length === 0 ? null : matchKey(ctx.request.header('authorization'), keys);
+    if (!matched) {
+        return ctx.response.unauthorized({
+            error: { code: 'unauthorized', message: 'API key ausente ou inválida.' },
+        });
+    }
+    // Anexa um id NÃO-SENSÍVEL da key ao contexto para a trilha de auditoria (M9).
+    ctx.adminApiKeyId = adminKeyId(matched);
+    return next();
+};

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

@@ -0,0 +1,125 @@
+import type { ResolvedServerConfig } from '../../define_config.js';
+import type { OrgSummary, OrgMember, OrgInvitation } from '../../accounts/account_store.js';
+import type { AdminActor } from './admin_users_service.js';
+import type { SettingsCapability } from '../runtime_settings.js';
+export interface OrgWithMemberCount extends OrgSummary {
+    memberCount: number;
+}
+export interface OrgDetail extends OrgSummary {
+    members: OrgMember[];
+    pendingInvitations: OrgInvitation[];
+}
+export interface CreateOrgInput {
+    name: string;
+    slug: string;
+    logoUrl?: string | null;
+    /** accountId do owner inicial da org. */
+    ownerAccountId: string;
+}
+export interface UpdateOrgInput {
+    name?: string;
+    logoUrl?: string | null;
+}
+export interface AddMemberInput {
+    accountId: string;
+    role: string;
+}
+export interface CreateInvitationInput {
+    email: string;
+    role: string;
+}
+export type OrgNotSupportedResult = {
+    ok: false;
+    reason: 'not_supported';
+};
+export type OrgNotFoundResult = {
+    ok: false;
+    reason: 'not_found';
+};
+export type LastOwnerResult = {
+    ok: false;
+    reason: 'last_owner';
+};
+export type InvalidRoleResult = {
+    ok: false;
+    reason: 'invalid_role';
+};
+/**
+ * Lógica de gestão de organizações compartilhada entre o console admin (HTML)
+ * e a Admin REST API (JSON). Usada pelos `AdminOrgsController` e `ApiOrgsController`.
+ * Todos os métodos de escrita auditam com o `actor` informado.
+ */
+export declare class AdminOrgsService {
+    private cfg;
+    constructor(cfg: ResolvedServerConfig);
+    get supported(): boolean;
+    /**
+     * Resolve o catálogo efetivo de roles de org (runtime settings → config →
+     * defaults da lib), garantindo sempre a presença de `owner`. Fail-safe: sem
+     * `settings`, usa o catálogo do config estático (`cfg.organizations`).
+     */
+    resolveRoleCatalog(settings: SettingsCapability | null, orgId?: string | null): Promise<string[]>;
+    /** Defaults estáticos de policy de org derivados do config do host. */
+    private orgPolicyConfigDefaults;
+    /**
+     * Valida um `role` de org contra o catálogo efetivo. Retorna `true` quando o
+     * role faz parte do catálogo. H4: bloqueia roles fora do catálogo (incluindo
+     * roles arbitrárias e, quando não catalogadas, `owner`).
+     *
+     * Delega ao helper PURO `isRoleInCatalog` de `runtime_toggles` — mesmo ponto de
+     * verdade usado pelo caminho member-facing (`account_orgs_controller`).
+     */
+    isRoleInCatalog(role: string, settings: SettingsCapability | null, orgId?: string | null): Promise<boolean>;
+    /** Lista todas as orgs com contagem de membros. */
+    listOrgs(): Promise<OrgWithMemberCount[] | OrgNotSupportedResult>;
+    /** Obtém uma org pelo id, com membros e convites pendentes. */
+    getOrg(orgId: string): Promise<OrgDetail | OrgNotSupportedResult | OrgNotFoundResult>;
+    /** Cria uma org. */
+    createOrg(input: CreateOrgInput, actor: AdminActor): Promise<OrgSummary | OrgNotSupportedResult | {
+        ok: false;
+        reason: 'slug_taken';
+    }>;
+    /** Atualiza nome/logo de uma org. */
+    updateOrg(orgId: string, patch: UpdateOrgInput, actor: AdminActor): Promise<OrgSummary | OrgNotSupportedResult | OrgNotFoundResult | {
+        ok: false;
+        reason: 'slug_taken';
+    }>;
+    /** Deleta uma org e todos os seus dados (membros + convites). */
+    deleteOrg(orgId: string, actor: AdminActor): Promise<{
+        ok: true;
+    } | OrgNotSupportedResult | OrgNotFoundResult>;
+    /** Adiciona um membro a uma org. */
+    addMember(orgId: string, input: AddMemberInput, actor: AdminActor, settings?: SettingsCapability | null): Promise<{
+        ok: true;
+    } | OrgNotSupportedResult | OrgNotFoundResult | InvalidRoleResult | {
+        ok: false;
+        reason: 'account_not_found';
+    }>;
+    /** Remove um membro de uma org. Respeita invariante last_owner. */
+    removeMember(orgId: string, accountId: string, actor: AdminActor): Promise<{
+        ok: true;
+    } | OrgNotSupportedResult | OrgNotFoundResult | LastOwnerResult | {
+        ok: false;
+        reason: 'member_not_found';
+    }>;
+    /** Troca o papel de um membro. Respeita invariante last_owner. */
+    updateMemberRole(orgId: string, accountId: string, newRole: string, actor: AdminActor, settings?: SettingsCapability | null): Promise<{
+        ok: true;
+    } | OrgNotSupportedResult | OrgNotFoundResult | LastOwnerResult | InvalidRoleResult | {
+        ok: false;
+        reason: 'member_not_found';
+    }>;
+    /** Cria um convite por e-mail. Dispara o mail hook quando configurado. */
+    createInvitation(orgId: string, input: CreateInvitationInput, actor: AdminActor, origin: string, settings?: SettingsCapability | null): Promise<{
+        ok: true;
+        invitation: OrgInvitation;
+        token: string;
+    } | OrgNotSupportedResult | OrgNotFoundResult | InvalidRoleResult>;
+    /** Revoga um convite. */
+    revokeInvitation(orgId: string, invitationId: string, actor: AdminActor): Promise<{
+        ok: true;
+    } | OrgNotSupportedResult | OrgNotFoundResult | {
+        ok: false;
+        reason: 'invitation_not_found';
+    }>;
+}