@beeuni/sdk 0.1.0

package/dist/core/agents/composer-agents.d.ts

@@ -0,0 +1,19 @@
+import type { Agent } from '../runtime/runtime-types.js';
+import type { ProjectConfigSummary } from '../rest/projects-client/index.js';
+export declare function projectConfigAgentsToRuntimeAgents(config: ProjectConfigSummary): Agent[];
+export declare function composerSelectableAgents(agents: Agent[] | undefined, options?: {
+    includeSubagents?: boolean;
+}): Agent[];
+export type ComposerAgentReason = 'loading' | 'selected' | 'bound' | 'default' | 'first_accessible' | 'no_access';
+export interface ComposerAgentResolution {
+    selected: string | null;
+    disabled: boolean;
+    reason: ComposerAgentReason;
+}
+export declare function resolveComposerAgent(input: {
+    agents: Agent[] | undefined;
+    boundAgent?: string | null;
+    defaultAgent?: string | null;
+    selectedAgent?: string | null;
+}): ComposerAgentResolution;
+export declare const projectConfigAgentsToOpenCodeAgents: typeof projectConfigAgentsToRuntimeAgents;

package/dist/core/agents/composer-agents.js

@@ -0,0 +1,57 @@
+import { isSelectableAgent } from '../rest/projects-client/project-agents.js';
+export function projectConfigAgentsToRuntimeAgents(config) {
+    const agents = config.agents.map(projectConfigAgentToOpenCodeAgent);
+    const defaultName = config.default_agent ?? config.open_code_default_agent;
+    if (!defaultName)
+        return agents;
+    return agents.sort((left, right) => {
+        if (left.name === defaultName)
+            return -1;
+        if (right.name === defaultName)
+            return 1;
+        return 0;
+    });
+}
+function projectConfigAgentToOpenCodeAgent(agent) {
+    return {
+        name: agent.name,
+        description: agent.description ?? undefined,
+        mode: agent.mode ?? undefined,
+        source: agent.source,
+        hidden: agent.enabled === false,
+    };
+}
+export function composerSelectableAgents(agents, options) {
+    if (!Array.isArray(agents))
+        return [];
+    const includeSubagents = options?.includeSubagents === true;
+    return agents.filter((a) => isSelectableAgent(includeSubagents ? { ...a, mode: null } : a));
+}
+export function resolveComposerAgent(input) {
+    const bound = input.boundAgent?.trim() || null;
+    if (!Array.isArray(input.agents)) {
+        const picked = input.selectedAgent?.trim();
+        if (picked)
+            return { selected: picked, disabled: false, reason: 'loading' };
+        return { selected: bound, disabled: false, reason: 'loading' };
+    }
+    const selectable = composerSelectableAgents(input.agents);
+    if (selectable.length === 0) {
+        if (bound)
+            return { selected: bound, disabled: false, reason: 'bound' };
+        return { selected: null, disabled: true, reason: 'no_access' };
+    }
+    const picked = input.selectedAgent?.trim();
+    if (picked && selectable.some((a) => a.name === picked)) {
+        return { selected: picked, disabled: false, reason: 'selected' };
+    }
+    if (bound) {
+        return { selected: bound, disabled: false, reason: 'bound' };
+    }
+    const declaredDefault = input.defaultAgent?.trim();
+    if (declaredDefault && selectable.some((a) => a.name === declaredDefault)) {
+        return { selected: declaredDefault, disabled: false, reason: 'default' };
+    }
+    return { selected: selectable[0].name, disabled: false, reason: 'first_accessible' };
+}
+export const projectConfigAgentsToOpenCodeAgents = projectConfigAgentsToRuntimeAgents;

package/dist/core/attachments/limits.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_PROMPT_ATTACHMENT_BYTES: number;
+export declare const MAX_PROMPT_ATTACHMENTS_BYTES: number;
+export declare const MAX_PROMPT_ATTACHMENT_FILES = 20;

package/dist/core/attachments/limits.js

@@ -0,0 +1,3 @@
+export const MAX_PROMPT_ATTACHMENT_BYTES = 50 * 1024 * 1024;
+export const MAX_PROMPT_ATTACHMENTS_BYTES = 100 * 1024 * 1024;
+export const MAX_PROMPT_ATTACHMENT_FILES = 20;

package/dist/core/attachments/prompt-attachments.d.ts

@@ -0,0 +1,37 @@
+import { type PromptAttachment } from '../rest/projects-client/prompt-attachments.js';
+import type { SessionPromptPart } from '../rest/projects-client/sessions.js';
+export type PromptAttachmentStatus = 'pending' | 'uploading' | 'processing' | 'ready' | 'error' | 'aborted';
+export interface PromptAttachmentItem {
+    readonly id: string;
+    readonly file?: File;
+    readonly filename: string;
+    readonly mime: string;
+    readonly size: number;
+    readonly status: PromptAttachmentStatus;
+    readonly receivedBytes: number;
+    readonly attachment?: PromptAttachment;
+    readonly error?: Error;
+}
+export interface PromptAttachmentSnapshot {
+    readonly attachments: readonly PromptAttachmentItem[];
+}
+export interface PromptAttachmentControllerOptions {
+    concurrency?: number;
+}
+export interface PromptAttachmentController {
+    add(file: File): string;
+    addMany(files: readonly File[]): string[];
+    retry(id: string): void;
+    remove(id: string): Promise<void>;
+    abort(id: string): void;
+    submit(ids: readonly string[]): void;
+    reclaim(ids: readonly string[]): void;
+    whenReady(ids: readonly string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<SessionPromptPart[]>;
+    forget(ids?: readonly string[]): void;
+    dispose(): void;
+    getSnapshot(): PromptAttachmentSnapshot;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createPromptAttachmentController(projectId: string | null | undefined, options?: PromptAttachmentControllerOptions): PromptAttachmentController;

package/dist/core/attachments/prompt-attachments.js

@@ -0,0 +1,377 @@
+import { createAbortError } from '../http/abort.js';
+import { ApiError } from '../http/api-client.js';
+import { deletePromptAttachment, uploadPromptAttachment, } from '../rest/projects-client/prompt-attachments.js';
+import { MAX_PROMPT_ATTACHMENT_BYTES, MAX_PROMPT_ATTACHMENTS_BYTES, MAX_PROMPT_ATTACHMENT_FILES, } from './limits.js';
+const PROGRESS_INTERVAL_MS = 100;
+let lastAttachmentId = 0;
+const FAILED_HANDLE_CODES = new Set(['attachment_size_mismatch', 'attachment_failed']);
+const expiredError = () => new ApiError('Attachment expired. Attach the file again.', { code: 'attachment_expired' });
+function completedMetadata(value) {
+    if (!value ||
+        typeof value.attachment_id !== 'string' ||
+        !value.attachment_id ||
+        typeof value.filename !== 'string' ||
+        !value.filename ||
+        typeof value.mime !== 'string' ||
+        !value.mime ||
+        !Number.isSafeInteger(value.size) ||
+        value.size <= 0 ||
+        value.size > MAX_PROMPT_ATTACHMENT_BYTES ||
+        !Number.isFinite(Date.parse(value.expires_at)) ||
+        Date.parse(value.expires_at) <= Date.now())
+        throw new Error('Attachment metadata is invalid or expired. Attach the file again.');
+    return {
+        attachment_id: value.attachment_id,
+        filename: value.filename,
+        mime: value.mime,
+        size: value.size,
+        expires_at: value.expires_at,
+    };
+}
+export function createPromptAttachmentController(projectId, options = {}) {
+    const concurrency = options.concurrency ?? 2;
+    if (!Number.isInteger(concurrency) ||
+        concurrency < 1 ||
+        concurrency > MAX_PROMPT_ATTACHMENT_FILES)
+        throw new Error('Attachment concurrency must be between 1 and 20');
+    const entries = new Map();
+    const listeners = new Set();
+    const waiters = new Set();
+    let active = 0;
+    let disposed = false;
+    let expiryTimer;
+    let snapshot = { attachments: [] };
+    const listed = () => [...entries.values()].filter((entry) => !entry.handedOff);
+    function deleteAfterRemoval(entry, attachmentId) {
+        if (entry.removalDeleted)
+            return;
+        entry.removalDeleted = true;
+        void deletePromptAttachment(projectId, attachmentId).catch(() => { });
+    }
+    function emit() {
+        if (expiryTimer)
+            clearTimeout(expiryTimer);
+        const attachments = listed().map(({ item }) => item);
+        if (attachments.length !== snapshot.attachments.length ||
+            attachments.some((item, index) => item !== snapshot.attachments[index]))
+            snapshot = { attachments };
+        const expiry = Math.min(...attachments
+            .filter((item) => item.status === 'ready')
+            .map((item) => Date.parse(item.attachment.expires_at)));
+        if (Number.isFinite(expiry) && !disposed) {
+            expiryTimer = setTimeout(() => {
+                for (const entry of listed()) {
+                    if (entry.item.status === 'ready' &&
+                        Date.parse(entry.item.attachment.expires_at) <= Date.now())
+                        entry.item = {
+                            ...entry.item,
+                            status: 'error',
+                            error: expiredError(),
+                        };
+                }
+                emit();
+            }, Math.min(2_147_483_647, Math.max(0, expiry - Date.now())));
+            if (typeof expiryTimer === 'object' && 'unref' in expiryTimer)
+                expiryTimer.unref();
+        }
+        for (const listener of listeners)
+            listener();
+        for (const check of [...waiters])
+            check();
+    }
+    function requireProject() {
+        if (disposed)
+            throw new Error('Attachment controller is disposed');
+        if (!projectId)
+            throw new Error('A project is required to attach files');
+        return projectId;
+    }
+    function validateSizes(sizes) {
+        requireProject();
+        const selection = listed();
+        if (selection.length + sizes.length > MAX_PROMPT_ATTACHMENT_FILES)
+            throw new Error('A message can contain up to 20 attachments');
+        if (sizes.some((size) => !Number.isSafeInteger(size) || size <= 0 || size > MAX_PROMPT_ATTACHMENT_BYTES))
+            throw new Error('Each attachment must contain 1 byte to 50 MiB');
+        const total = selection.reduce((sum, entry) => sum + entry.item.size, 0) +
+            sizes.reduce((sum, size) => sum + size, 0);
+        if (total > MAX_PROMPT_ATTACHMENTS_BYTES)
+            throw new Error('Message attachments exceed 100 MiB');
+    }
+    function pump() {
+        for (const entry of entries.values()) {
+            if (active >= concurrency)
+                break;
+            if (entry.item.status !== 'pending' || !entry.item.file)
+                continue;
+            if (disposed && !entry.handedOff)
+                continue;
+            const file = entry.item.file;
+            active++;
+            const generation = ++entry.generation;
+            const abort = new AbortController();
+            entry.abort = abort;
+            entry.item = { ...entry.item, status: 'uploading', error: undefined };
+            const current = () => (!disposed || entry.handedOff === true) &&
+                entries.get(entry.item.id) === entry &&
+                entry.generation === generation;
+            let unseenBytes;
+            let seenAt = 0;
+            let progressTimer;
+            const showProgress = () => {
+                progressTimer = undefined;
+                if (!current() || entry.item.status !== 'uploading' || unseenBytes === undefined)
+                    return;
+                entry.item = { ...entry.item, receivedBytes: unseenBytes };
+                unseenBytes = undefined;
+                seenAt = Date.now();
+                emit();
+            };
+            const percent = (bytes) => Math.floor((bytes * 100) / entry.item.size);
+            void uploadPromptAttachment(projectId, file, {
+                resume: entry.upload,
+                signal: abort.signal,
+                onUpload: (upload) => {
+                    entry.upload = upload;
+                    if (entry.removed) {
+                        abort.abort();
+                        deleteAfterRemoval(entry, upload.attachment_id);
+                    }
+                },
+                onProgress: (receivedBytes) => {
+                    if (!current() || percent(receivedBytes) === percent(entry.item.receivedBytes))
+                        return;
+                    unseenBytes = receivedBytes;
+                    if (progressTimer)
+                        return;
+                    const wait = seenAt + PROGRESS_INTERVAL_MS - Date.now();
+                    if (wait <= 0)
+                        return showProgress();
+                    progressTimer = setTimeout(showProgress, wait);
+                    if (typeof progressTimer === 'object' && 'unref' in progressTimer)
+                        progressTimer.unref();
+                },
+                onProcessing: () => {
+                    if (progressTimer)
+                        clearTimeout(progressTimer);
+                    progressTimer = undefined;
+                    unseenBytes = undefined;
+                    if (current()) {
+                        entry.item = { ...entry.item, status: 'processing', receivedBytes: entry.item.size };
+                        emit();
+                    }
+                },
+            })
+                .then((attachment) => {
+                if (current()) {
+                    entry.item = {
+                        ...entry.item,
+                        status: 'ready',
+                        attachment: completedMetadata(attachment),
+                        receivedBytes: attachment.size,
+                    };
+                }
+            })
+                .catch((error) => {
+                if (error instanceof ApiError && FAILED_HANDLE_CODES.has(error.code ?? ''))
+                    entry.upload = undefined;
+                if (current())
+                    entry.item = {
+                        ...entry.item,
+                        status: error instanceof ApiError && error.code === 'ABORTED' ? 'aborted' : 'error',
+                        error: error instanceof Error ? error : new Error(String(error)),
+                    };
+            })
+                .finally(() => {
+                active--;
+                if (progressTimer)
+                    clearTimeout(progressTimer);
+                if (entry.abort === abort)
+                    entry.abort = undefined;
+                emit();
+                pump();
+            });
+        }
+        emit();
+    }
+    function addMany(files) {
+        validateSizes(files.map((file) => file.size));
+        const ids = files.map((file) => {
+            const id = `attachment-${++lastAttachmentId}`;
+            entries.set(id, {
+                generation: 0,
+                item: {
+                    id,
+                    file,
+                    filename: file.name,
+                    mime: file.type || 'application/octet-stream',
+                    size: file.size,
+                    status: 'pending',
+                    receivedBytes: 0,
+                },
+            });
+            return id;
+        });
+        emit();
+        pump();
+        return ids;
+    }
+    function abort(id) {
+        const entry = entries.get(id);
+        if (!entry || entry.item.status === 'ready')
+            return;
+        entry.generation++;
+        entry.abort?.abort();
+        entry.item = {
+            ...entry.item,
+            status: 'aborted',
+            error: new Error('Attachment upload cancelled'),
+        };
+        emit();
+    }
+    function whenReady(ids, { signal } = {}) {
+        const wanted = [...ids];
+        return new Promise((resolve, reject) => {
+            const stop = () => {
+                waiters.delete(check);
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const fail = (error) => {
+                stop();
+                reject(error);
+            };
+            const onAbort = () => fail(createAbortError());
+            const check = () => {
+                let waiting = false;
+                for (const id of wanted) {
+                    const entry = entries.get(id);
+                    if (!entry)
+                        return fail(new Error('Attachment was removed before it was sent'));
+                    if (disposed && !entry.handedOff)
+                        return fail(new Error('Attachment controller is disposed'));
+                    if (entry.item.status === 'error' || entry.item.status === 'aborted')
+                        return fail(entry.item.error ?? new Error('Attachment upload failed'));
+                    if (entry.item.status !== 'ready')
+                        waiting = true;
+                }
+                if (waiting)
+                    return;
+                let parts;
+                try {
+                    parts = wanted.map((id) => {
+                        const attachment = completedMetadata(entries.get(id).item.attachment);
+                        return {
+                            type: 'file',
+                            attachment_id: attachment.attachment_id,
+                            filename: attachment.filename,
+                            mime: attachment.mime,
+                        };
+                    });
+                }
+                catch (error) {
+                    return fail(error instanceof Error ? error : new Error(String(error)));
+                }
+                stop();
+                resolve(parts);
+            };
+            if (signal?.aborted)
+                return onAbort();
+            waiters.add(check);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            check();
+        });
+    }
+    return {
+        add: (file) => addMany([file])[0],
+        addMany,
+        retry(id) {
+            const entry = entries.get(id);
+            if (!entry?.handedOff)
+                requireProject();
+            if (!entry ||
+                entry.item.status === 'ready' ||
+                entry.item.status === 'uploading' ||
+                entry.item.status === 'processing' ||
+                entry.item.status === 'pending')
+                return;
+            if (!entry.item.file || (entry.upload && Date.parse(entry.upload.expires_at) <= Date.now()))
+                throw expiredError();
+            entry.item = { ...entry.item, status: 'pending', error: undefined };
+            pump();
+        },
+        async remove(id) {
+            const entry = entries.get(id);
+            if (!entry)
+                return;
+            entry.removed = true;
+            entry.generation++;
+            entries.delete(id);
+            const attachmentId = entry.upload?.attachment_id ?? entry.item.attachment?.attachment_id;
+            if (attachmentId)
+                entry.abort?.abort();
+            emit();
+            pump();
+            if (attachmentId)
+                deleteAfterRemoval(entry, attachmentId);
+        },
+        abort,
+        submit(ids) {
+            if (disposed)
+                return;
+            for (const id of ids) {
+                const entry = entries.get(id);
+                if (entry)
+                    entry.handedOff = true;
+            }
+            emit();
+        },
+        reclaim(ids) {
+            if (disposed)
+                return;
+            for (const id of ids) {
+                const entry = entries.get(id);
+                if (entry)
+                    entry.handedOff = false;
+            }
+            emit();
+        },
+        whenReady,
+        forget(ids = listed().map((entry) => entry.item.id)) {
+            for (const id of ids) {
+                const entry = entries.get(id);
+                if (entry) {
+                    entry.generation++;
+                    entry.abort?.abort();
+                    entries.delete(id);
+                }
+            }
+            emit();
+            pump();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (expiryTimer)
+                clearTimeout(expiryTimer);
+            for (const entry of entries.values()) {
+                if (entry.handedOff)
+                    continue;
+                entry.generation++;
+                entry.abort?.abort();
+                const attachmentId = entry.upload?.attachment_id ?? entry.item.attachment?.attachment_id;
+                if (attachmentId && projectId)
+                    void deletePromptAttachment(projectId, attachmentId).catch(() => { });
+            }
+            listeners.clear();
+            emit();
+        },
+        getSnapshot: () => snapshot,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/core/auth/app-viewer.d.ts

@@ -0,0 +1,43 @@
+export interface BeeuniAppViewerSession {
+    app_id: string;
+    access_mode: string;
+    account_id: string;
+    user_id: string;
+    email: string | null;
+    name?: string | null;
+    picture?: string | null;
+    group_ids: string[];
+    groups?: string[];
+    role?: string | null;
+    project_id?: string;
+    scopes: string[];
+    access_token: string | null;
+    expires_at: string | null;
+}
+export interface BeeuniAppViewerOptions {
+    path?: string;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+export declare function clearBeeuniAppViewerCache(): void;
+export declare function fetchBeeuniAppViewer(options?: BeeuniAppViewerOptions): Promise<BeeuniAppViewerSession | null>;
+export declare function beeuniAppViewerToken(options?: BeeuniAppViewerOptions): (() => Promise<string | null>) & {
+    invalidate: (rejectedToken: string) => void;
+};
+export interface BeeuniTokenOptions {
+    audience?: string;
+    path?: string;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+export type BeeuniTokenFetcher = (args?: {
+    forceRefreshToken?: boolean;
+}) => Promise<string | null>;
+export declare function beeuniToken(options?: BeeuniTokenOptions): BeeuniTokenFetcher;
+export interface BeeuniBindingOptions {
+    origin?: string;
+    fetch?: BeeuniTokenOptions['fetch'];
+}
+export interface BeeuniBinding {
+    url: string;
+    token: BeeuniTokenFetcher;
+}
+export declare function beeuniBinding(slug: string, options?: BeeuniBindingOptions): BeeuniBinding;

package/dist/core/auth/app-viewer.js

@@ -0,0 +1,104 @@
+import { stripTrailingSlashes } from '../../platform/strings.js';
+const DEFAULT_PATH = '/_beeuni/viewer';
+const REFRESH_SKEW_MS = 60_000;
+const cache = new Map();
+export function clearBeeuniAppViewerCache() {
+    cache.clear();
+    appTokens.clear();
+}
+async function load(path, fetchImpl) {
+    let res;
+    try {
+        res = await fetchImpl(path, { credentials: 'same-origin', headers: { accept: 'application/json' } });
+    }
+    catch {
+        return null;
+    }
+    if (res.status === 401 || res.status === 404)
+        return null;
+    if (!res.ok)
+        return null;
+    const session = (await res.json().catch(() => null));
+    return session && typeof session.user_id === 'string' ? session : null;
+}
+export async function fetchBeeuniAppViewer(options = {}) {
+    const path = options.path ?? DEFAULT_PATH;
+    const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    const entry = cache.get(path);
+    if (entry && !entry.inflight && entry.expiresAt > Date.now())
+        return entry.session;
+    if (entry?.inflight)
+        return entry.inflight;
+    const inflight = load(path, fetchImpl).then((session) => {
+        const expiry = session?.expires_at ? Date.parse(session.expires_at) : Number.NaN;
+        const expiresAt = Number.isFinite(expiry) ? expiry - REFRESH_SKEW_MS : Date.now() + REFRESH_SKEW_MS;
+        cache.set(path, { session, expiresAt });
+        return session;
+    });
+    cache.set(path, { session: entry?.session ?? null, expiresAt: 0, inflight });
+    return inflight;
+}
+export function beeuniAppViewerToken(options = {}) {
+    const path = options.path ?? DEFAULT_PATH;
+    return Object.assign(async () => (await fetchBeeuniAppViewer(options))?.access_token ?? null, {
+        invalidate: (rejectedToken) => {
+            const entry = cache.get(path);
+            if (entry && !entry.inflight && entry.session?.access_token === rejectedToken)
+                cache.delete(path);
+        },
+    });
+}
+const appTokens = new Map();
+async function loadAppToken(url, fetchImpl) {
+    try {
+        const res = await fetchImpl(url, { credentials: 'same-origin', headers: { accept: 'application/json' } });
+        if (!res.ok) {
+            if (res.status === 403) {
+                const refusal = (await res.json().catch(() => null));
+                if (refusal?.error === 'app_not_linked')
+                    console.warn(`[beeuni] ${String(refusal.error_description)}`);
+            }
+            return null;
+        }
+        const body = (await res.json().catch(() => null));
+        if (!body || typeof body.token !== 'string')
+            return null;
+        const expiry = typeof body.expires_at === 'string' ? Date.parse(body.expires_at) : Number.NaN;
+        appTokens.set(url, {
+            token: body.token,
+            refreshAt: Number.isFinite(expiry) ? expiry - REFRESH_SKEW_MS : Date.now() + REFRESH_SKEW_MS,
+        });
+        return body.token;
+    }
+    catch {
+        return null;
+    }
+}
+export function beeuniToken(options = {}) {
+    const base = options.path ?? '/_beeuni/token';
+    const url = options.audience === undefined ? base : `${base}?audience=${encodeURIComponent(options.audience)}`;
+    const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    return async (args = {}) => {
+        const entry = appTokens.get(url);
+        if (entry instanceof Promise)
+            return entry;
+        if (entry && !args.forceRefreshToken && entry.refreshAt > Date.now())
+            return entry.token;
+        const inflight = loadAppToken(url, fetchImpl).then((token) => {
+            if (token === null)
+                appTokens.delete(url);
+            return token;
+        });
+        appTokens.set(url, inflight);
+        return inflight;
+    };
+}
+export function beeuniBinding(slug, options = {}) {
+    const origin = options.origin ?? globalThis.location?.origin;
+    if (!origin)
+        throw new Error('beeuniBinding needs the App origin: pass { origin } outside a browser.');
+    return {
+        url: `${stripTrailingSlashes(origin)}/_beeuni/apps/${encodeURIComponent(slug)}`,
+        token: beeuniToken({ audience: slug, fetch: options.fetch }),
+    };
+}

package/dist/core/auth/beeuni-member.d.ts

@@ -0,0 +1,31 @@
+export interface BeeuniMember {
+    userId: string;
+    email: string | null;
+    name: string | null;
+    picture: string | null;
+    groups: string[];
+    groupIds: string[];
+    role: string | null;
+    accountId: string | null;
+    projectId: string | null;
+}
+export interface BeeuniMemberRequirement {
+    groups?: string[];
+    roles?: string[];
+}
+export declare class BeeuniMemberError extends Error {
+    readonly code: 'unauthenticated' | 'forbidden';
+    constructor(code: 'unauthenticated' | 'forbidden', message: string);
+}
+export declare function readBeeuniMember(claims: unknown): BeeuniMember | null;
+export declare function requireBeeuniMember(claims: unknown, requirement?: BeeuniMemberRequirement): BeeuniMember;
+export type BeeuniMemberKeySet = {
+    keys: JsonWebKey[];
+} | string;
+export interface VerifyBeeuniTokenOptions {
+    jwks?: BeeuniMemberKeySet;
+    issuer?: string;
+    audience?: string | false;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+export declare function verifyBeeuniToken(token: string, options?: VerifyBeeuniTokenOptions): Promise<BeeuniMember>;