@adonis-agora/authkit-client 0.9.0

package/build/src/middleware/auth_middleware.js

@@ -0,0 +1,36 @@
+/**
+ * Middleware de autenticação pronto do AuthKit: exige sessão válida (`ctx.auth.check()`)
+ * e, opcionalmente, papéis (global OU app). Substitui o middleware de auth que cada
+ * consumidor reescrevia à mão.
+ *
+ * ```ts
+ * // start/kernel.ts
+ * export const middleware = router.named({
+ *   auth: () => import('@adonis-agora/authkit-client/auth_middleware'),
+ * })
+ * // uso: .use(middleware.auth({ roles: ['ADVISOR'], redirectTo: '/auth/login' }))
+ * ```
+ */
+export default class AuthkitAuthMiddleware {
+    async handle(ctx, next, options = {}) {
+        const redirectTo = options.redirectTo ?? '/auth/login';
+        const ok = await ctx.auth.check();
+        if (!ok)
+            return ctx.response.redirect(redirectTo);
+        if (options.roles?.length) {
+            const isGlobal = options.roles.some((r) => ctx.auth.hasGlobalRole(r));
+            let allowed = isGlobal;
+            if (!allowed) {
+                for (const r of options.roles) {
+                    if (await ctx.auth.hasAppRole(r)) {
+                        allowed = true;
+                        break;
+                    }
+                }
+            }
+            if (!allowed)
+                return ctx.response.redirect(options.unauthorizedRedirect ?? '/unauthorized');
+        }
+        return next();
+    }
+}

package/build/src/middleware/authkit_middleware.d.ts

@@ -0,0 +1,5 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { NextFn } from '@adonisjs/core/types/http';
+export default class AuthkitMiddleware {
+    handle(ctx: HttpContext, next: NextFn): Promise<any>;
+}

package/build/src/middleware/authkit_middleware.js

@@ -0,0 +1,9 @@
+export default class AuthkitMiddleware {
+    async handle(ctx, next) {
+        const manager = await ctx.containerResolver.make('authkit.client');
+        // Renova proativamente o TokenSet (rotação de refresh token) antes de resolver.
+        await manager.maybeRefresh(ctx);
+        ctx.auth = await manager.createAuthenticator(ctx);
+        return next();
+    }
+}

package/build/src/middleware/backchannel_revocation_middleware.d.ts

@@ -0,0 +1,18 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { NextFn } from '@adonisjs/core/types/http';
+/**
+ * Aplica revogações de OIDC Back-Channel Logout sobre sessões COOKIE-BASED.
+ *
+ * Sem store server-side não dá pra destruir a sessão no instante do logout_token;
+ * este middleware roda em toda request COM token set na sessão, extrai sid/sub/iat
+ * do id_token e, se a sessão foi revogada (via {@link RevocationStore}), limpa o
+ * token set local — o resolver downstream trata como não-autenticado.
+ *
+ * No-op quando `backchannelLogout.store` não está configurado em `config/authkit_client.ts`.
+ *
+ * Ordem no kernel: DEPOIS do `authkit_middleware` (depende do `authkit.client`
+ * resolvido), antes dos named middlewares de auth.
+ */
+export default class BackchannelRevocationMiddleware {
+    handle(ctx: HttpContext, next: NextFn): Promise<any>;
+}

package/build/src/middleware/backchannel_revocation_middleware.js

@@ -0,0 +1,50 @@
+/**
+ * Aplica revogações de OIDC Back-Channel Logout sobre sessões COOKIE-BASED.
+ *
+ * Sem store server-side não dá pra destruir a sessão no instante do logout_token;
+ * este middleware roda em toda request COM token set na sessão, extrai sid/sub/iat
+ * do id_token e, se a sessão foi revogada (via {@link RevocationStore}), limpa o
+ * token set local — o resolver downstream trata como não-autenticado.
+ *
+ * No-op quando `backchannelLogout.store` não está configurado em `config/authkit_client.ts`.
+ *
+ * Ordem no kernel: DEPOIS do `authkit_middleware` (depende do `authkit.client`
+ * resolvido), antes dos named middlewares de auth.
+ */
+export default class BackchannelRevocationMiddleware {
+    async handle(ctx, next) {
+        const manager = await ctx.containerResolver.make('authkit.client');
+        const store = manager.clientConfig.backchannelStore;
+        if (!store)
+            return next();
+        const sessionKey = manager.clientConfig.sessionKey;
+        const idToken = manager.getIdToken(ctx);
+        if (idToken) {
+            const claims = decodeJwtPayload(idToken);
+            const sid = typeof claims?.sid === 'string' ? claims.sid : undefined;
+            const sub = typeof claims?.sub === 'string' ? claims.sub : undefined;
+            const authTime = typeof claims?.iat === 'number' ? claims.iat : undefined;
+            if ((sid || sub) && (await store.isRevoked({ sid, sub, authTime }))) {
+                // session é augmentado por @adonisjs/session no app host; na lib usamos cast.
+                ;
+                ctx.session?.forget(sessionKey);
+            }
+        }
+        return next();
+    }
+}
+/**
+ * Decodifica o payload de um JWT SEM verificar assinatura — seguro aqui porque o
+ * id_token foi validado no login e vive numa sessão assinada/encriptada pelo app.
+ */
+function decodeJwtPayload(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3)
+        return null;
+    try {
+        return JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/build/src/middleware/silent_auth_middleware.d.ts

@@ -0,0 +1,13 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { NextFn } from '@adonisjs/core/types/http';
+/**
+ * Resolve a identidade da sessão (popula `ctx.auth`) SEM exigir login — útil em
+ * rotas públicas que mostram estado logado/deslogado. Nunca redireciona.
+ *
+ * ```ts
+ * silentAuth: () => import('@adonis-agora/authkit-client/silent_auth_middleware'),
+ * ```
+ */
+export default class AuthkitSilentAuthMiddleware {
+    handle(ctx: HttpContext, next: NextFn): Promise<any>;
+}

package/build/src/middleware/silent_auth_middleware.js

@@ -0,0 +1,14 @@
+/**
+ * Resolve a identidade da sessão (popula `ctx.auth`) SEM exigir login — útil em
+ * rotas públicas que mostram estado logado/deslogado. Nunca redireciona.
+ *
+ * ```ts
+ * silentAuth: () => import('@adonis-agora/authkit-client/silent_auth_middleware'),
+ * ```
+ */
+export default class AuthkitSilentAuthMiddleware {
+    async handle(ctx, next) {
+        await ctx.auth.check();
+        return next();
+    }
+}

package/build/src/observability/client_metrics.d.ts

@@ -0,0 +1,10 @@
+import { type AuthkitMetricName, type MetricsRecorder, type MetricsSnapshot } from '@adonis-agora/authkit-core';
+/** Recorder que (best-effort) emite via @opentelemetry/api e SEMPRE agrega em memória. */
+export declare class OtelRecorder implements MetricsRecorder {
+    #private;
+    private constructor();
+    static create(name: string): Promise<OtelRecorder>;
+    increment(name: AuthkitMetricName, attributes?: Record<string, string | number>): void;
+    record(name: AuthkitMetricName, value: number, attributes?: Record<string, string | number>): void;
+    snapshot(): MetricsSnapshot;
+}

package/build/src/observability/client_metrics.js

@@ -0,0 +1,59 @@
+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;
+};
+import { InMemorySnapshot, } from '@adonis-agora/authkit-core';
+/** Recorder que (best-effort) emite via @opentelemetry/api e SEMPRE agrega em memória. */
+export class OtelRecorder {
+    #snapshot = new InMemorySnapshot();
+    #counters = new Map();
+    #histograms = new Map();
+    #meter;
+    constructor(meter) {
+        this.#meter = meter;
+    }
+    static async create(name) {
+        let meter = null;
+        try {
+            // Specifier dinâmico (não-estático) para que o TS não tente resolver o
+            // peer opcional @opentelemetry/api em tempo de compilação. Em runtime,
+            // se o pacote não estiver instalado, caímos no catch e ficamos no-op.
+            const moduleName = '@opentelemetry/api';
+            const otel = await import(__rewriteRelativeImportExtension(moduleName));
+            meter = otel.metrics.getMeter(name);
+        }
+        catch {
+            meter = null;
+        }
+        return new OtelRecorder(meter);
+    }
+    increment(name, attributes) {
+        this.#snapshot.bump(name);
+        if (!this.#meter)
+            return;
+        let c = this.#counters.get(name);
+        if (!c) {
+            c = this.#meter.createCounter(name);
+            this.#counters.set(name, c);
+        }
+        c.add(1, attributes);
+    }
+    record(name, value, attributes) {
+        this.#snapshot.observe(name, value);
+        if (!this.#meter)
+            return;
+        let h = this.#histograms.get(name);
+        if (!h) {
+            h = this.#meter.createHistogram(name);
+            this.#histograms.set(name, h);
+        }
+        h.record(value, attributes);
+    }
+    snapshot() {
+        return this.#snapshot.read();
+    }
+}

package/build/src/observability/context_bridge.d.ts

@@ -0,0 +1,7 @@
+import type { Identity } from "@adonis-agora/authkit-core";
+/**
+ * Popula o contexto do Agora a partir de uma identidade recém-resolvida:
+ * `userRef` ({ type: 'user', id: userId }) e, quando presente nas claims,
+ * `tenantId`. Best-effort: qualquer erro é engolido e nada acontece sem o slot.
+ */
+export declare function populateContext(identity: Identity): void;

package/build/src/observability/context_bridge.js

@@ -0,0 +1,49 @@
+/**
+ * Ponte estrutural (best-effort) entre a sessão resolvida do authkit e o
+ * contexto do Agora. Lê o slot global `@agora/context:set` de forma ESTRUTURAL —
+ * nunca importa `@adonis-agora/context` — e degrada para no-op quando o context
+ * não está instalado. Mesmo idioma da `diagnostics_bridge`.
+ */
+const SET_SLOT = Symbol.for("@agora/context:set");
+/**
+ * Claims OIDC candidatas a "organização/tenant ativo". A primeira presente (e
+ * string não vazia) vira o `tenantId`. Não falha se nenhuma existir.
+ */
+const TENANT_CLAIMS = [
+    "active_organization_id",
+    "org_id",
+    "organization_id",
+    "tenant_id",
+    "tid",
+];
+/** Deriva o tenant ativo das claims cruas, ou `undefined` quando ausente. */
+function deriveTenant(raw) {
+    if (!raw)
+        return undefined;
+    for (const claim of TENANT_CLAIMS) {
+        const value = raw[claim];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Popula o contexto do Agora a partir de uma identidade recém-resolvida:
+ * `userRef` ({ type: 'user', id: userId }) e, quando presente nas claims,
+ * `tenantId`. Best-effort: qualquer erro é engolido e nada acontece sem o slot.
+ */
+export function populateContext(identity) {
+    try {
+        const set = globalThis[SET_SLOT];
+        if (!set)
+            return;
+        const tenant = deriveTenant(identity.raw);
+        set({
+            userRef: { type: "user", id: identity.userId },
+            ...(tenant ? { tenantId: tenant } : {}),
+        });
+    }
+    catch {
+        // best-effort: a ponte de contexto nunca quebra o caminho da request.
+    }
+}

package/build/src/oidc_login.d.ts

@@ -0,0 +1,113 @@
+import type { TokenSet } from "./types.js";
+import { type ResiliencePolicy } from "./http/resilient_fetch.js";
+/**
+ * Gera um par PKCE (code_verifier + code_challenge) usando o método S256.
+ *
+ * Observação: o `jose` v5 instalado não exporta os helpers
+ * `generateRandomCodeVerifier`/`calculatePKCECodeChallenge`, então usamos o
+ * `crypto` do Node + `jose.base64url` para produzir valores equivalentes,
+ * conforme RFC 7636 (verifier aleatório base64url, challenge = base64url(SHA-256(verifier))).
+ */
+export declare function generatePkce(): Promise<{
+    verifier: string;
+    challenge: string;
+    method: "S256";
+}>;
+export interface AuthorizeParams {
+    issuer: string;
+    clientId: string;
+    redirectUri: string;
+    scopes: string[];
+    state: string;
+    codeChallenge: string;
+    /**
+     * Endpoint de autorização do IdP — obtenha via `discoverEndpoints(issuer)`
+     * para IdPs de terceiros. Default: `${issuer}/auth` (convenção oidc-provider).
+     */
+    authorizationEndpoint?: string;
+    /**
+     * Parâmetros extras anexados à URL de autorização (ex.: `audience`, `prompt`,
+     * `login_hint`, `ui_locales`, `acr_values`). Evita manipulação manual de URL no
+     * controller. Valores `undefined`/`null` são ignorados.
+     */
+    extraParams?: Record<string, string | number | undefined | null>;
+}
+export declare function buildAuthorizeUrl(p: AuthorizeParams): string;
+export interface EndSessionParams {
+    /** Issuer do IdP (ex.: http://localhost:3333/oidc). */
+    issuer: string;
+    /** ID token atual da sessão; usado como id_token_hint para o IdP pular a confirmação. */
+    idToken?: string;
+    /** URI registrada no client onde o IdP devolve o browser após encerrar a sessão. */
+    postLogoutRedirectUri?: string;
+    /** Opcional; alguns IdPs exigem client_id quando não há id_token_hint. */
+    clientId?: string;
+    /** Opcional; ecoado de volta no post_logout_redirect_uri. */
+    state?: string;
+    /**
+     * Endpoint de end-session do IdP (via `discoverEndpoints`). Default:
+     * `${issuer}/session/end` (convenção oidc-provider).
+     */
+    endSessionEndpoint?: string;
+}
+/**
+ * Monta a URL de RP-initiated logout (OIDC) do IdP: `<issuer>/session/end`.
+ *
+ * Com `id_token_hint` + `post_logout_redirect_uri` registrada no client, o
+ * oidc-provider encerra a sessão SSO e redireciona o browser de volta. Sem
+ * o `id_token_hint`, o oidc-provider (v9) renderiza uma página de confirmação.
+ */
+export declare function buildEndSessionUrl(p: EndSessionParams): string;
+export interface ExchangeParams {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    redirectUri: string;
+    code: string;
+    codeVerifier: string;
+    fetchImpl?: typeof fetch;
+    /** Token endpoint do IdP (via `discoverEndpoints`). Default: `${issuer}/token`. */
+    tokenEndpoint?: string;
+    /** Política de resiliência OPCIONAL p/ a chamada ao token endpoint. */
+    resilience?: ResiliencePolicy;
+}
+export declare function exchangeCode(p: ExchangeParams): Promise<TokenSet>;
+export interface RefreshParams {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    refreshToken: string;
+    /** Escopo opcional para reduzir o escopo do novo token. */
+    scope?: string;
+    fetchImpl?: typeof fetch;
+    /** Token endpoint do IdP (via `discoverEndpoints`). Default: `${issuer}/token`. */
+    tokenEndpoint?: string;
+    /** Política de resiliência OPCIONAL p/ a chamada ao token endpoint. */
+    resilience?: ResiliencePolicy;
+}
+/**
+ * Renova o TokenSet via `grant_type=refresh_token` (RFC 6749 §6).
+ *
+ * Com rotação habilitada no IdP (oidc-provider `rotateRefreshToken`), o endpoint
+ * devolve um NOVO refresh_token a cada uso e invalida o anterior — o chamador
+ * DEVE persistir o `refreshToken` retornado. Se o IdP não rotacionar, o campo
+ * pode vir vazio e o refresh token anterior continua válido.
+ */
+export declare function refreshTokens(p: RefreshParams): Promise<TokenSet>;
+export interface ExchangeTokenParams {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    /** Access token atual do ator (admin). */
+    subjectToken: string;
+    /** Id do usuário-alvo a impersonar. */
+    requestedSubject: string;
+    scope?: string;
+    fetchImpl?: typeof fetch;
+    /** Token endpoint do IdP (via `discoverEndpoints`). Default: `${issuer}/token`. */
+    tokenEndpoint?: string;
+    /** Política de resiliência OPCIONAL p/ a chamada ao token endpoint. */
+    resilience?: ResiliencePolicy;
+}
+/** Troca o token do ator por um token do usuário-alvo (RFC 8693), p/ impersonation. */
+export declare function exchangeToken(p: ExchangeTokenParams): Promise<TokenSet>;

package/build/src/oidc_login.js

@@ -0,0 +1,123 @@
+import { createHash, randomBytes } from "node:crypto";
+import { base64url } from "jose";
+import { resilientFetch, } from "./http/resilient_fetch.js";
+/**
+ * Gera um par PKCE (code_verifier + code_challenge) usando o método S256.
+ *
+ * Observação: o `jose` v5 instalado não exporta os helpers
+ * `generateRandomCodeVerifier`/`calculatePKCECodeChallenge`, então usamos o
+ * `crypto` do Node + `jose.base64url` para produzir valores equivalentes,
+ * conforme RFC 7636 (verifier aleatório base64url, challenge = base64url(SHA-256(verifier))).
+ */
+export async function generatePkce() {
+    const verifier = base64url.encode(randomBytes(32));
+    const challenge = base64url.encode(createHash("sha256").update(verifier).digest());
+    return { verifier, challenge, method: "S256" };
+}
+export function buildAuthorizeUrl(p) {
+    const url = new URL(p.authorizationEndpoint ?? `${p.issuer}/auth`);
+    url.searchParams.set("client_id", p.clientId);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("redirect_uri", p.redirectUri);
+    url.searchParams.set("scope", p.scopes.join(" "));
+    url.searchParams.set("state", p.state);
+    url.searchParams.set("code_challenge", p.codeChallenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    if (p.extraParams) {
+        for (const [key, value] of Object.entries(p.extraParams)) {
+            if (value !== undefined && value !== null)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    return url.toString();
+}
+/**
+ * Monta a URL de RP-initiated logout (OIDC) do IdP: `<issuer>/session/end`.
+ *
+ * Com `id_token_hint` + `post_logout_redirect_uri` registrada no client, o
+ * oidc-provider encerra a sessão SSO e redireciona o browser de volta. Sem
+ * o `id_token_hint`, o oidc-provider (v9) renderiza uma página de confirmação.
+ */
+export function buildEndSessionUrl(p) {
+    const url = new URL(p.endSessionEndpoint ?? `${p.issuer}/session/end`);
+    if (p.idToken)
+        url.searchParams.set("id_token_hint", p.idToken);
+    if (p.postLogoutRedirectUri) {
+        url.searchParams.set("post_logout_redirect_uri", p.postLogoutRedirectUri);
+    }
+    if (p.clientId)
+        url.searchParams.set("client_id", p.clientId);
+    if (p.state)
+        url.searchParams.set("state", p.state);
+    return url.toString();
+}
+/**
+ * POST genérico ao token endpoint (`<issuer>/token`) compartilhado pelos fluxos
+ * authorization_code, refresh_token e token-exchange. Mapeia a resposta para um
+ * TokenSet padronizado e lança se o endpoint não responder 2xx.
+ */
+async function tokenEndpoint(issuer, body, fetchImpl = fetch, endpoint, resilience) {
+    const res = await resilientFetch(endpoint ?? `${issuer}/token`, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: body.toString(),
+    }, resilience, fetchImpl);
+    if (!res.ok)
+        throw new Error(`Token endpoint returned ${res.status}`);
+    const json = (await res.json());
+    return {
+        idToken: json.id_token ?? "",
+        accessToken: json.access_token,
+        refreshToken: json.refresh_token,
+        expiresAt: json.expires_in
+            ? Date.now() + json.expires_in * 1000
+            : undefined,
+    };
+}
+export async function exchangeCode(p) {
+    const body = new URLSearchParams({
+        grant_type: "authorization_code",
+        code: p.code,
+        redirect_uri: p.redirectUri,
+        client_id: p.clientId,
+        code_verifier: p.codeVerifier,
+    });
+    if (p.clientSecret)
+        body.set("client_secret", p.clientSecret);
+    return tokenEndpoint(p.issuer, body, p.fetchImpl, p.tokenEndpoint, p.resilience);
+}
+/**
+ * Renova o TokenSet via `grant_type=refresh_token` (RFC 6749 §6).
+ *
+ * Com rotação habilitada no IdP (oidc-provider `rotateRefreshToken`), o endpoint
+ * devolve um NOVO refresh_token a cada uso e invalida o anterior — o chamador
+ * DEVE persistir o `refreshToken` retornado. Se o IdP não rotacionar, o campo
+ * pode vir vazio e o refresh token anterior continua válido.
+ */
+export async function refreshTokens(p) {
+    const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: p.refreshToken,
+        client_id: p.clientId,
+    });
+    if (p.scope)
+        body.set("scope", p.scope);
+    if (p.clientSecret)
+        body.set("client_secret", p.clientSecret);
+    return tokenEndpoint(p.issuer, body, p.fetchImpl, p.tokenEndpoint, p.resilience);
+}
+/** Troca o token do ator por um token do usuário-alvo (RFC 8693), p/ impersonation. */
+export async function exchangeToken(p) {
+    const body = new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+        subject_token: p.subjectToken,
+        subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
+        requested_subject: p.requestedSubject,
+        client_id: p.clientId,
+    });
+    if (p.scope)
+        body.set("scope", p.scope);
+    if (p.clientSecret)
+        body.set("client_secret", p.clientSecret);
+    return tokenEndpoint(p.issuer, body, p.fetchImpl, p.tokenEndpoint, p.resilience);
+}

package/build/src/register_oidc_client.d.ts

@@ -0,0 +1,50 @@
+import type { Router } from '@adonisjs/core/http';
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Identity } from '@adonis-agora/authkit-core';
+/**
+ * Mapa role → rota de redirect pós-login. `byGlobalRole` checa as roles globais do
+ * IdP (claim); `byAppRole` checa `resolveAppRoles`. A primeira correspondência vence
+ * (global antes de app); sem match → `default`.
+ */
+export interface PostLoginRedirects {
+    byGlobalRole?: Record<string, string>;
+    byAppRole?: Record<string, string>;
+    default?: string;
+}
+export interface RegisterOidcClientOptions {
+    /** Prefixo das rotas. Default `/auth` → `/auth/login`, `/auth/callback`, `/auth/logout`. */
+    prefix?: string;
+    /**
+     * Hook após troca de code bem-sucedida. Retorne uma STRING para redirecionar
+     * para uma rota específica; retorne void para cair em `redirects`/`/`.
+     */
+    afterLogin?: (ctx: HttpContext, identity: Identity | null) => Promise<string | void> | string | void;
+    /** Redirect pós-login por papel (usado quando `afterLogin` não retorna string). */
+    redirects?: PostLoginRedirects;
+    /** Destino pós-logout. Default: origem do redirectUri + '/'. */
+    postLogoutRedirect?: string | ((ctx: HttpContext) => string);
+    /** Registra também `POST {prefix}/backchannel-logout` (OIDC Back-Channel Logout). Default: true. */
+    backchannelLogout?: boolean;
+    /**
+     * Middleware(s) aplicados à rota de login (ex.: `middleware.guest()`). Array no
+     * formato aceito por `.use()` do AdonisJS.
+     */
+    loginMiddleware?: any;
+    /** Query param repassado como hint ao authorize (ex.: `audience`). Default: `['audience']`. */
+    passthroughParams?: string[];
+}
+/**
+ * Registra as rotas OIDC de CLIENT (login/callback/logout [+ back-channel logout])
+ * absorvendo o boilerplate que cada app reescrevia no OidcSessionController: PKCE +
+ * state na sessão, troca de code, validação, logout RP-initiated e redirect por papel.
+ *
+ * ```ts
+ * // start/routes.ts
+ * import { registerOidcClient } from '@adonis-agora/authkit-client'
+ * registerOidcClient(router, {
+ *   loginMiddleware: middleware.guest(),
+ *   redirects: { byGlobalRole: { ADMIN: '/admin' }, byAppRole: { ADVISOR: '/advisor' }, default: '/' },
+ * })
+ * ```
+ */
+export declare function registerOidcClient(router: Router, options?: RegisterOidcClientOptions): void;