doover-js 0.11.0 → 0.12.1

package/dist/esm/apis/notifications-api.js

@@ -0,0 +1,153 @@
+import { resolveAgentArgs } from "./_args.js";
+export class NotificationsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    getAgentNotifications(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentNotifications(agentId);
+    }
+    _getAgentNotifications(agentId) {
+        return this.rest.get(`/agents/${agentId}/notifications`);
+    }
+    getAgentNotificationEndpoints(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentNotificationEndpoints(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentNotificationEndpoints(id.agentId, args[1]);
+    }
+    _getAgentNotificationEndpoints(agentId, name) {
+        return this.rest.get(`/agents/${agentId}/notifications/endpoints`, { name });
+    }
+    getAgentNotificationEndpointSummaries(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentNotificationEndpointSummaries(agentId);
+    }
+    _getAgentNotificationEndpointSummaries(agentId) {
+        return this.rest.get(`/agents/${agentId}/notifications/endpoints/summary`);
+    }
+    createNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._createNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._createNotificationEndpoint(id.agentId, args[1]);
+    }
+    _createNotificationEndpoint(agentId, body) {
+        return this.rest.post(`/agents/${agentId}/notifications/endpoints`, body);
+    }
+    updateNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateNotificationEndpoint(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateNotificationEndpoint(id.agentId, args[1], args[2]);
+    }
+    _updateNotificationEndpoint(agentId, endpointId, body) {
+        return this.rest.patch(`/agents/${agentId}/notifications/endpoints/${endpointId}`, body);
+    }
+    deleteNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteNotificationEndpoint(id.agentId, args[1]);
+    }
+    _deleteNotificationEndpoint(agentId, endpointId) {
+        return this.rest.delete(`/agents/${agentId}/notifications/endpoints/${endpointId}`);
+    }
+    testNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._testNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._testNotificationEndpoint(id.agentId, args[1]);
+    }
+    _testNotificationEndpoint(agentId, endpointId) {
+        return this.rest.post(`/agents/${agentId}/notifications/endpoints/${endpointId}/test`, {});
+    }
+    getAgentNotificationSubscriptions(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentNotificationSubscriptions(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentNotificationSubscriptions(id.agentId, args[1]);
+    }
+    _getAgentNotificationSubscriptions(agentId, subscribed_to) {
+        return this.rest.get(`/agents/${agentId}/notifications/subscriptions`, { subscribed_to });
+    }
+    createNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._createNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._createNotificationSubscription(id.agentId, args[1]);
+    }
+    _createNotificationSubscription(agentId, body) {
+        return this.rest.post(`/agents/${agentId}/notifications/subscriptions`, body);
+    }
+    getAgentDefaultNotificationSubscriptions(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentDefaultNotificationSubscriptions(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentDefaultNotificationSubscriptions(id.agentId, args[1]);
+    }
+    _getAgentDefaultNotificationSubscriptions(agentId, subscribed_to) {
+        return this.rest.get(`/agents/${agentId}/notifications/subscriptions/default`, { subscribed_to });
+    }
+    updateDefaultNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateDefaultNotificationSubscription(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateDefaultNotificationSubscription(id.agentId, args[1], args[2]);
+    }
+    _updateDefaultNotificationSubscription(agentId, subscribedTo, body) {
+        return this.rest.patch(`/agents/${agentId}/notifications/subscriptions/default/${subscribedTo}`, body);
+    }
+    deleteDefaultNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteDefaultNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteDefaultNotificationSubscription(id.agentId, args[1]);
+    }
+    _deleteDefaultNotificationSubscription(agentId, subscribedTo) {
+        return this.rest.delete(`/agents/${agentId}/notifications/subscriptions/default/${subscribedTo}`);
+    }
+    updateNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateNotificationSubscription(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateNotificationSubscription(id.agentId, args[1], args[2]);
+    }
+    _updateNotificationSubscription(agentId, subscriptionId, body) {
+        return this.rest.patch(`/agents/${agentId}/notifications/subscriptions/${subscriptionId}`, body);
+    }
+    deleteNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteNotificationSubscription(id.agentId, args[1]);
+    }
+    _deleteNotificationSubscription(agentId, subscriptionId) {
+        return this.rest.delete(`/agents/${agentId}/notifications/subscriptions/${subscriptionId}`);
+    }
+    getAgentNotificationSubscribers(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentNotificationSubscribers(agentId);
+    }
+    _getAgentNotificationSubscribers(agentId) {
+        return this.rest.get(`/agents/${agentId}/notifications/subscribers`);
+    }
+    updateMeWebPushEndpoint(body) {
+        return this.rest.post("/agents/me/notifications/update_web_push", body);
+    }
+    getWebPushPublicKey() {
+        return this.rest.get("/notifications/webpush-public-key");
+    }
+}

package/dist/esm/apis/organisations-api.d.ts

@@ -0,0 +1,26 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { CustomerSite, Organisation, PaginatedResponse } from "../types/viewer.js";
+export interface ListOrganisationsOptions {
+    page?: number;
+    perPage?: number;
+    search?: string;
+    archived?: boolean | "";
+    ordering?: string;
+    name?: string;
+    name__contains?: string;
+    name__icontains?: string;
+    id?: string | number;
+    [key: string]: string | number | boolean | "" | undefined;
+}
+export declare class OrganisationsApi {
+    private readonly rest;
+    private readonly controlApiUrl?;
+    constructor(rest: RestClient, controlApiUrl?: string | undefined);
+    listOrganisations(options?: ListOrganisationsOptions): Promise<PaginatedResponse<Organisation>>;
+    getOrganisation(id: string): Promise<Organisation>;
+    /**
+     * Convert an organisation record from `/organisations/` into the smaller
+     * customer-site bootstrap shape returned by `/site/`.
+     */
+    toCustomerSite(organisation: Organisation): CustomerSite;
+}

package/dist/esm/apis/organisations-api.js

@@ -0,0 +1,41 @@
+export class OrganisationsApi {
+    constructor(rest, controlApiUrl) {
+        this.rest = rest;
+        this.controlApiUrl = controlApiUrl;
+    }
+    listOrganisations(options) {
+        return this.rest.get("/organisations/", buildListQuery(options), this.controlApiUrl);
+    }
+    getOrganisation(id) {
+        return this.rest.get(`/organisations/${id}/`, undefined, this.controlApiUrl);
+    }
+    /**
+     * Convert an organisation record from `/organisations/` into the smaller
+     * customer-site bootstrap shape returned by `/site/`.
+     */
+    toCustomerSite(organisation) {
+        return {
+            id: organisation.id,
+            name: organisation.name,
+            application_id: organisation.application_id,
+            archived: organisation.archived,
+            theme: organisation.theme ?? {},
+        };
+    }
+}
+function buildListQuery(options) {
+    if (!options)
+        return undefined;
+    const { page, perPage, ...rest } = options;
+    const query = {};
+    if (page !== undefined)
+        query.page = page;
+    if (perPage !== undefined)
+        query.per_page = perPage;
+    for (const [key, value] of Object.entries(rest)) {
+        if (value === undefined)
+            continue;
+        query[key] = value;
+    }
+    return query;
+}

package/dist/esm/apis/permissions-api.d.ts

@@ -0,0 +1,17 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { AgentPermission, PermissionDebugResponse, SuccessListResponse, SyncPermissionRequest } from "../types/openapi.js";
+export declare class PermissionsApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    getAgentPermission(agentId: string): Promise<AgentPermission>;
+    getAgentPermission(identifier: {
+        agentId: string;
+    }): Promise<AgentPermission>;
+    private _getAgentPermission;
+    getAgentPermissionDebug(agentId: string): Promise<PermissionDebugResponse>;
+    getAgentPermissionDebug(identifier: {
+        agentId: string;
+    }): Promise<PermissionDebugResponse>;
+    private _getAgentPermissionDebug;
+    syncPermissions(body: SyncPermissionRequest): Promise<SuccessListResponse<string>>;
+}

package/dist/esm/apis/permissions-api.js

@@ -0,0 +1,23 @@
+import { resolveAgentArgs } from "./_args.js";
+export class PermissionsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    getAgentPermission(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentPermission(agentId);
+    }
+    _getAgentPermission(agentId) {
+        return this.rest.get(`/agents/${agentId}/permissions`);
+    }
+    getAgentPermissionDebug(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentPermissionDebug(agentId);
+    }
+    _getAgentPermissionDebug(agentId) {
+        return this.rest.get(`/agents/${agentId}/permissions/debug`);
+    }
+    syncPermissions(body) {
+        return this.rest.post("/permissions/sync", body);
+    }
+}

package/dist/esm/apis/processors-api.d.ts

@@ -0,0 +1,56 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { CreateIngestionRequest, PutScheduleRequest, PutSubscriptionRequest, ScheduleInfo, SubscriptionInfo } from "../types/openapi.js";
+export declare class ProcessorsApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    createProcessorSchedule(agentId: string, scheduleId: string, body: PutScheduleRequest): Promise<unknown>;
+    createProcessorSchedule(identifier: {
+        agentId: string;
+    }, scheduleId: string, body: PutScheduleRequest): Promise<unknown>;
+    private _createProcessorSchedule;
+    deleteProcessorSchedule(agentId: string, scheduleId: string): Promise<unknown>;
+    deleteProcessorSchedule(identifier: {
+        agentId: string;
+    }, scheduleId: string): Promise<unknown>;
+    private _deleteProcessorSchedule;
+    regenerateScheduleToken(agentId: string, scheduleId: string): Promise<unknown>;
+    regenerateScheduleToken(identifier: {
+        agentId: string;
+    }, scheduleId: string): Promise<unknown>;
+    private _regenerateScheduleToken;
+    getScheduleInfo(scheduleId: string): Promise<ScheduleInfo>;
+    getScheduleInfoAlias(scheduleId: string): Promise<ScheduleInfo>;
+    createProcessorSubscription(agentId: string, subscriptionId: string, body: PutSubscriptionRequest): Promise<unknown>;
+    createProcessorSubscription(identifier: {
+        agentId: string;
+    }, subscriptionId: string, body: PutSubscriptionRequest): Promise<unknown>;
+    private _createProcessorSubscription;
+    deleteProcessorSubscription(agentId: string, subscriptionId: string): Promise<unknown>;
+    deleteProcessorSubscription(identifier: {
+        agentId: string;
+    }, subscriptionId: string): Promise<unknown>;
+    private _deleteProcessorSubscription;
+    getProcessorSubscriptionInfo(subscriptionName: string): Promise<SubscriptionInfo>;
+    getProcessorSubscriptionInfoAlias(subscriptionArn: string): Promise<SubscriptionInfo>;
+    createIngestionEndpoint(agentId: string, ingestionId: string, body: CreateIngestionRequest): Promise<unknown>;
+    createIngestionEndpoint(identifier: {
+        agentId: string;
+    }, ingestionId: string, body: CreateIngestionRequest): Promise<unknown>;
+    private _createIngestionEndpoint;
+    deleteIngestionEndpoint(agentId: string, ingestionId: string): Promise<unknown>;
+    deleteIngestionEndpoint(identifier: {
+        agentId: string;
+    }, ingestionId: string): Promise<unknown>;
+    private _deleteIngestionEndpoint;
+    invokeIngestionEndpoint(agentId: string, ingestionId: string, body: unknown, params?: {
+        wait?: boolean;
+        json_response?: boolean;
+    }): Promise<unknown>;
+    invokeIngestionEndpoint(identifier: {
+        agentId: string;
+    }, ingestionId: string, body: unknown, params?: {
+        wait?: boolean;
+        json_response?: boolean;
+    }): Promise<unknown>;
+    private _invokeIngestionEndpoint;
+}

package/dist/esm/apis/processors-api.js

@@ -0,0 +1,97 @@
+export class ProcessorsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    createProcessorSchedule(...args) {
+        if (typeof args[0] === "string") {
+            return this._createProcessorSchedule(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._createProcessorSchedule(id.agentId, args[1], args[2]);
+    }
+    _createProcessorSchedule(agentId, scheduleId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/schedules/${scheduleId}`, body);
+    }
+    deleteProcessorSchedule(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteProcessorSchedule(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteProcessorSchedule(id.agentId, args[1]);
+    }
+    _deleteProcessorSchedule(agentId, scheduleId) {
+        return this.rest.delete(`/agents/${agentId}/processors/schedules/${scheduleId}`);
+    }
+    regenerateScheduleToken(...args) {
+        if (typeof args[0] === "string") {
+            return this._regenerateScheduleToken(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._regenerateScheduleToken(id.agentId, args[1]);
+    }
+    _regenerateScheduleToken(agentId, scheduleId) {
+        return this.rest.post(`/agents/${agentId}/processors/schedules/${scheduleId}/token`, {});
+    }
+    getScheduleInfo(scheduleId) {
+        return this.rest.get(`/processors/schedules/${scheduleId}`);
+    }
+    getScheduleInfoAlias(scheduleId) {
+        return this.rest.get(`/processors/schedules/${scheduleId}/info`);
+    }
+    createProcessorSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._createProcessorSubscription(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._createProcessorSubscription(id.agentId, args[1], args[2]);
+    }
+    _createProcessorSubscription(agentId, subscriptionId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/subscriptions/${subscriptionId}`, body);
+    }
+    deleteProcessorSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteProcessorSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteProcessorSubscription(id.agentId, args[1]);
+    }
+    _deleteProcessorSubscription(agentId, subscriptionId) {
+        return this.rest.delete(`/agents/${agentId}/processors/subscriptions/${subscriptionId}`);
+    }
+    getProcessorSubscriptionInfo(subscriptionName) {
+        return this.rest.get(`/processors/subscriptions/${subscriptionName}`);
+    }
+    getProcessorSubscriptionInfoAlias(subscriptionArn) {
+        return this.rest.get(`/processors/subscriptions/${subscriptionArn}/info`);
+    }
+    createIngestionEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._createIngestionEndpoint(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._createIngestionEndpoint(id.agentId, args[1], args[2]);
+    }
+    _createIngestionEndpoint(agentId, ingestionId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/ingestions/${ingestionId}`, body);
+    }
+    deleteIngestionEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteIngestionEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteIngestionEndpoint(id.agentId, args[1]);
+    }
+    _deleteIngestionEndpoint(agentId, ingestionId) {
+        return this.rest.delete(`/agents/${agentId}/processors/ingestions/${ingestionId}`);
+    }
+    invokeIngestionEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._invokeIngestionEndpoint(args[0], args[1], args[2], args[3]);
+        }
+        const id = args[0];
+        return this._invokeIngestionEndpoint(id.agentId, args[1], args[2], args[3]);
+    }
+    _invokeIngestionEndpoint(agentId, ingestionId, body, params) {
+        return this.rest.post(`/agents/${agentId}/processors/ingestions/${ingestionId}/invoke`, body, params);
+    }
+}

package/dist/esm/apis/turn-api.d.ts

@@ -0,0 +1,7 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { TurnCredential, TurnTokenRequest } from "../types/openapi.js";
+export declare class TurnApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    createTurnToken(body: TurnTokenRequest): Promise<TurnCredential>;
+}

package/dist/esm/apis/turn-api.js

@@ -0,0 +1,8 @@
+export class TurnApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    createTurnToken(body) {
+        return this.rest.post("/turn/token", body);
+    }
+}

package/dist/esm/apis/users-api.d.ts

@@ -0,0 +1,8 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { User } from "../types/viewer.js";
+export declare class UsersApi {
+    private readonly rest;
+    private readonly controlApiUrl?;
+    constructor(rest: RestClient, controlApiUrl?: string | undefined);
+    getMe(): Promise<User>;
+}

package/dist/esm/apis/users-api.js

@@ -0,0 +1,9 @@
+export class UsersApi {
+    constructor(rest, controlApiUrl) {
+        this.rest = rest;
+        this.controlApiUrl = controlApiUrl;
+    }
+    getMe() {
+        return this.rest.get("/users/me", undefined, this.controlApiUrl);
+    }
+}

package/dist/esm/auth/auth-profile.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Browser-safe value object representing a single Doover auth profile.
+ *
+ * Property names use camelCase JS conventions. The static helpers `parse` and
+ * `dump` translate to/from the on-disk format shared with pydoover.
+ */
+export interface AuthProfileData {
+    profile?: string;
+    token?: string | null;
+    tokenExpires?: string | null;
+    agentId?: string | null;
+    controlBaseUrl?: string | null;
+    dataBaseUrl?: string | null;
+    refreshToken?: string | null;
+    refreshTokenId?: string | null;
+    authServerUrl?: string | null;
+    authServerClientId?: string | null;
+}
+export declare class AuthProfile {
+    profile: string;
+    token: string | null;
+    tokenExpires: string | null;
+    agentId: string | null;
+    controlBaseUrl: string | null;
+    dataBaseUrl: string | null;
+    refreshToken: string | null;
+    refreshTokenId: string | null;
+    authServerUrl: string | null;
+    authServerClientId: string | null;
+    constructor(data: AuthProfileData & {
+        profile: string;
+    });
+    /**
+     * Parse a block of lines (excluding the `[profile=...]` header) into an
+     * `AuthProfile`. The profile name must be provided separately.
+     */
+    static parse(profileName: string, lines: string[]): AuthProfile;
+    /**
+     * Serialise to the on-disk reduced format (without the `[profile=...]`
+     * header line, which the caller is responsible for).
+     */
+    dump(): string;
+    /** Full block including the header line. */
+    dumpBlock(): string;
+}

package/dist/esm/auth/auth-profile.js

@@ -0,0 +1,68 @@
+/** On-disk key → JS property mapping (pydoover reduced-format Doover2). */
+const DISK_KEY_MAP = {
+    TOKEN: "token",
+    TOKEN_EXPIRES: "tokenExpires",
+    AGENT_ID: "agentId",
+    BASE_URL: "controlBaseUrl",
+    BASE_DATA_URL: "dataBaseUrl",
+    REFRESH_TOKEN: "refreshToken",
+    REFRESH_TOKEN_ID: "refreshTokenId",
+    AUTH_SERVER_URL: "authServerUrl",
+    AUTH_SERVER_CLIENT_ID: "authServerClientId",
+};
+/** JS property → on-disk key mapping. */
+const JS_KEY_MAP = Object.fromEntries(Object.entries(DISK_KEY_MAP).map(([disk, js]) => [js, disk]));
+export class AuthProfile {
+    constructor(data) {
+        this.profile = data.profile;
+        this.token = data.token ?? null;
+        this.tokenExpires = data.tokenExpires ?? null;
+        this.agentId = data.agentId ?? null;
+        this.controlBaseUrl = data.controlBaseUrl ?? null;
+        this.dataBaseUrl = data.dataBaseUrl ?? null;
+        this.refreshToken = data.refreshToken ?? null;
+        this.refreshTokenId = data.refreshTokenId ?? null;
+        this.authServerUrl = data.authServerUrl ?? null;
+        this.authServerClientId = data.authServerClientId ?? null;
+    }
+    /**
+     * Parse a block of lines (excluding the `[profile=...]` header) into an
+     * `AuthProfile`. The profile name must be provided separately.
+     */
+    static parse(profileName, lines) {
+        const data = { profile: profileName };
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            const value = trimmed.slice(eqIdx + 1).trim();
+            const jsProp = DISK_KEY_MAP[key];
+            if (jsProp) {
+                data[jsProp] = value || null;
+            }
+        }
+        return new AuthProfile(data);
+    }
+    /**
+     * Serialise to the on-disk reduced format (without the `[profile=...]`
+     * header line, which the caller is responsible for).
+     */
+    dump() {
+        const lines = [];
+        for (const jsProp of Object.keys(JS_KEY_MAP)) {
+            const value = this[jsProp];
+            if (value !== null && value !== undefined) {
+                lines.push(`${JS_KEY_MAP[jsProp]}=${value}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    /** Full block including the header line. */
+    dumpBlock() {
+        return `[profile=${this.profile}]\n${this.dump()}`;
+    }
+}

package/dist/esm/auth/auth-store.d.ts

@@ -0,0 +1,14 @@
+import type { AuthProfile } from "./auth-profile.js";
+/**
+ * Structural interface for profile stores accepted by auth classes.
+ * Implementations may be backed by files (ConfigManager in the Node subpath)
+ * or by in-memory stores for testing.
+ */
+export interface AuthProfileStore {
+    currentProfile: string | null;
+    current: AuthProfile | null;
+    get(profileName: string): AuthProfile | undefined;
+    create(entry: AuthProfile): void;
+    delete(profileName: string): void;
+    write(): void;
+}

package/dist/esm/auth/build-auth.d.ts

@@ -0,0 +1,38 @@
+import type { AuthProfile } from "./auth-profile.js";
+import type { AuthProfileStore } from "./auth-store.js";
+import { DooverAuth } from "./doover-auth.js";
+/**
+ * Raw auth inputs that can be provided in client configs.
+ *
+ * If `auth` is provided it is used as-is and raw inputs must not be combined
+ * with it. Otherwise these fields are used to build the appropriate auth
+ * instance automatically.
+ */
+export interface AuthConfig {
+    auth?: DooverAuth;
+    profile?: string | AuthProfile;
+    configManager?: AuthProfileStore;
+    token?: string | null;
+    tokenExpires?: Date | number | null;
+    refreshToken?: string | null;
+    refreshTokenId?: string | null;
+    authServerUrl?: string | null;
+    authServerClientId?: string | null;
+}
+/** Fetch implementation to thread through to DooverTokenAuth. */
+interface BuildAuthOptions extends AuthConfig {
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Build a `DooverAuth` instance from the provided configuration.
+ *
+ * Rules:
+ * 1. If `auth` is provided it is returned as-is.
+ * 2. If any token material is present, build `DooverTokenAuth`.
+ * 3. If `profile` is an `AuthProfile`, use it to seed a `DooverTokenAuth`.
+ * 4. If `profile` is a string, look it up via `configManager`.
+ * 5. Otherwise fall back to `CookieAuth`, refresh-capable when
+ *    `authServerUrl` is known.
+ */
+export declare function buildAuth(options: BuildAuthOptions): DooverAuth;
+export {};