@agentforge-io/sdk-console 0.0.0-stage → 0.2.0

package/dist/resources/templates.d.ts

@@ -0,0 +1,115 @@
+import type { HttpCore } from '../http';
+import type { InstallTemplateInput, ListTemplatesInput, SaveTemplateInput, SignListingAssetInput, SignedUpload, Template, TemplateConfigField, TemplateConfigFields, TemplateInstallResult, TemplateListingPatch, TemplatePolicyCheck, TemplateReadiness, TemplateSourceStatus, TemplateVersionRow, TemplateVersionView, UpdateFromTemplateResult, UpdatesAvailable, VersionDiff, VersionHistory } from '../types';
+export declare class TemplatesResource {
+    protected readonly http: HttpCore;
+    constructor(http: HttpCore);
+    /** `GET /public/templates`: system + public, listed rows only. */
+    listPublic(input?: Omit<ListTemplatesInput, 'publisherAppId'>): Promise<{
+        items: Template[];
+    }>;
+    /** `GET /public/templates/:id` (404 for tenant-private or unlisted rows). */
+    getPublic(templateId: string): Promise<Template>;
+    /** `GET /templates/:id` (with payload). */
+    get(templateId: string): Promise<Template>;
+    /** `PATCH /templates/:id`: metadata + listing (name, logo, cover, categories, guide, locale). */
+    updateListing(templateId: string, patch: TemplateListingPatch): Promise<Template>;
+    /** `GET /templates/:id/policy-check`: dry run of an App's template policy against a version
+     *  (default: open draft, else published). `publisherAppId` defaults to the template's own publisher. */
+    policyCheck(templateId: string, input?: {
+        publisherAppId?: string;
+        version?: number;
+    }): Promise<TemplatePolicyCheck>;
+    /** `POST /templates/:id/listing-assets/sign`: PUT the bytes to `uploadUrl`, then `updateListing({ logoUrl | coverUrl: publicUrl })`. */
+    signListingAsset(templateId: string, input: SignListingAssetInput): Promise<SignedUpload>;
+    /** `GET /templates/:id/versions` (published snapshots). */
+    listVersions(templateId: string): Promise<{
+        items: TemplateVersionRow[];
+    }>;
+    /** `GET /templates/:id/version-history` */
+    versionHistory(templateId: string): Promise<VersionHistory>;
+    /** `GET /templates/:id/diff?from=&to=`; `to: 'source'` compares with the live source team. */
+    diff(templateId: string, from: number, to: number | 'source'): Promise<VersionDiff>;
+    /** `POST /templates/:id/drafts`: snapshot the source team as a new draft version. */
+    snapshotDraft(templateId: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/submit`: draft -> in review. */
+    submitVersion(templateId: string, version: number, changelog: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/review` */
+    reviewVersion(templateId: string, version: number, decision: 'approved' | 'changes_requested', comment?: string): Promise<TemplateVersionView>;
+    /** `POST /templates/:id/versions/:v/publish` */
+    publishVersion(templateId: string, version: number, changelog?: string): Promise<TemplateVersionView>;
+    /** `DELETE /templates/:id/versions/:v`: discard a draft. */
+    discardVersion(templateId: string, version: number): Promise<{
+        ok: true;
+    }>;
+    /** `POST /templates/:id/versions/:v/restore`: new draft from an old version. */
+    restoreVersion(templateId: string, version: number): Promise<TemplateVersionView>;
+    /** `PUT /templates/:id/source`: make a team of the template's workspace its source. */
+    linkSource(templateId: string, teamId: string): Promise<{
+        ok: true;
+    }>;
+    /** `DELETE /templates/:id/source` */
+    unlinkSource(templateId: string): Promise<{
+        ok: true;
+    }>;
+    /** `POST /templates/:id/source/copy`: create the editable copy from the published version and link it. */
+    createSourceCopy(templateId: string): Promise<{
+        teamId: string;
+    }>;
+    /** `PATCH /templates/:id/review-policy` */
+    setReviewPolicy(templateId: string, policy: {
+        requiredApprovals: number | null;
+        approverUserIds: string[] | null;
+    }): Promise<{
+        ok: true;
+    }>;
+    /** `GET /templates/:id/config-fields` (open draft, else published). */
+    configFields(templateId: string): Promise<TemplateConfigFields>;
+    /** `PUT /templates/:id/config-fields` (saved on the open draft). 400 `invalid_config_schema` if malformed. */
+    setConfigFields(templateId: string, configSchema: TemplateConfigField[]): Promise<{
+        draftVersion: number | null;
+    }>;
+}
+/** `forTenant(id).templates`: everything of `client.templates` plus the workspace-bound calls. */
+export declare class TenantTemplatesResource extends TemplatesResource {
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get tenantBase();
+    /** `GET /templates?tenantId=`: system + public + this workspace's own. */
+    list(input?: ListTemplatesInput): Promise<{
+        items: Template[];
+    }>;
+    /** `POST /templates/:id/install` into this workspace. */
+    install(templateId: string, input?: InstallTemplateInput): Promise<TemplateInstallResult>;
+    /** `GET /templates/:id/install-readiness?destinationTenantId=`: what is ready / needs setup before installing here. */
+    installReadiness(templateId: string): Promise<TemplateReadiness>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/save-as-template` */
+    saveAgentAsTemplate(agentId: string, input?: SaveTemplateInput): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/save-as-template` */
+    saveTeamAsTemplate(teamId: string, input?: SaveTemplateInput): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/publish-template-version` */
+    publishAgentTemplateVersion(agentId: string, input: {
+        templateId: string;
+        changelog?: string;
+        publisherAppId?: string | null;
+    }): Promise<Template>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/publish-template-version` */
+    publishTeamTemplateVersion(teamId: string, input: {
+        templateId: string;
+        changelog?: string;
+        publisherAppId?: string | null;
+    }): Promise<Template>;
+    /** `GET /admin/tenants/:tenantId/teams/:teamId/template-source`: the template this team is the source of, with its version state. */
+    templateSource(teamId: string): Promise<{
+        source: TemplateSourceStatus | null;
+    }>;
+    /** `GET /me/template-updates-available?tenantId=`: installed agents/teams behind their template. */
+    updatesAvailable(): Promise<UpdatesAvailable>;
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/update-from-template` */
+    updateTeamFromTemplate(teamId: string, input?: {
+        targetVersion?: number;
+    }): Promise<UpdateFromTemplateResult>;
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/update-from-template` */
+    updateAgentFromTemplate(agentId: string, input?: {
+        targetVersion?: number;
+    }): Promise<UpdateFromTemplateResult>;
+}

package/dist/resources/templates.js

@@ -0,0 +1,187 @@
+"use strict";
+// templates: gallery, detail, listing, version lifecycle (`client.templates`),
+// plus the workspace-bound calls (`forTenant(id).templates`): install, save as
+// template, publish a version, updates of installed teams.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantTemplatesResource = exports.TemplatesResource = void 0;
+const http_1 = require("../http");
+function listQuery(input) {
+    return {
+        kind: input.kind,
+        q: input.q,
+        categories: input.categories,
+        primaryCategory: input.primaryCategory,
+        publisherAppId: input.publisherAppId,
+        limit: input.limit,
+    };
+}
+class TemplatesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    // ─── Public gallery (no session) ─────────────────────────────────────
+    /** `GET /public/templates`: system + public, listed rows only. */
+    async listPublic(input = {}) {
+        return this.http.request('GET', '/public/templates', { query: listQuery(input), auth: false });
+    }
+    /** `GET /public/templates/:id` (404 for tenant-private or unlisted rows). */
+    async getPublic(templateId) {
+        return this.http.request('GET', `/public/templates/${(0, http_1.seg)(templateId)}`, { auth: false });
+    }
+    // ─── Detail & listing ────────────────────────────────────────────────
+    /** `GET /templates/:id` (with payload). */
+    async get(templateId) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}`);
+    }
+    /** `PATCH /templates/:id`: metadata + listing (name, logo, cover, categories, guide, locale). */
+    async updateListing(templateId, patch) {
+        return this.http.request('PATCH', `/templates/${(0, http_1.seg)(templateId)}`, { body: patch });
+    }
+    /** `GET /templates/:id/policy-check`: dry run of an App's template policy against a version
+     *  (default: open draft, else published). `publisherAppId` defaults to the template's own publisher. */
+    async policyCheck(templateId, input = {}) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/policy-check`, {
+            query: { publisherAppId: input.publisherAppId, version: input.version },
+        });
+    }
+    /** `POST /templates/:id/listing-assets/sign`: PUT the bytes to `uploadUrl`, then `updateListing({ logoUrl | coverUrl: publicUrl })`. */
+    async signListingAsset(templateId, input) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/listing-assets/sign`, { body: input });
+    }
+    /** `GET /templates/:id/versions` (published snapshots). */
+    async listVersions(templateId) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/versions`);
+    }
+    // ─── Version lifecycle (AGF-TEMPLATE-VERSIONS) ───────────────────────
+    /** `GET /templates/:id/version-history` */
+    async versionHistory(templateId) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/version-history`);
+    }
+    /** `GET /templates/:id/diff?from=&to=`; `to: 'source'` compares with the live source team. */
+    async diff(templateId, from, to) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/diff`, { query: { from, to } });
+    }
+    /** `POST /templates/:id/drafts`: snapshot the source team as a new draft version. */
+    async snapshotDraft(templateId) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/drafts`, { body: {} });
+    }
+    /** `POST /templates/:id/versions/:v/submit`: draft -> in review. */
+    async submitVersion(templateId, version, changelog) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/versions/${version}/submit`, {
+            body: { changelog },
+        });
+    }
+    /** `POST /templates/:id/versions/:v/review` */
+    async reviewVersion(templateId, version, decision, comment) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/versions/${version}/review`, {
+            body: { decision, comment },
+        });
+    }
+    /** `POST /templates/:id/versions/:v/publish` */
+    async publishVersion(templateId, version, changelog) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/versions/${version}/publish`, {
+            body: { changelog },
+        });
+    }
+    /** `DELETE /templates/:id/versions/:v`: discard a draft. */
+    async discardVersion(templateId, version) {
+        return this.http.request('DELETE', `/templates/${(0, http_1.seg)(templateId)}/versions/${version}`);
+    }
+    /** `POST /templates/:id/versions/:v/restore`: new draft from an old version. */
+    async restoreVersion(templateId, version) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/versions/${version}/restore`, { body: {} });
+    }
+    /** `PUT /templates/:id/source`: make a team of the template's workspace its source. */
+    async linkSource(templateId, teamId) {
+        return this.http.request('PUT', `/templates/${(0, http_1.seg)(templateId)}/source`, { body: { teamId } });
+    }
+    /** `DELETE /templates/:id/source` */
+    async unlinkSource(templateId) {
+        return this.http.request('DELETE', `/templates/${(0, http_1.seg)(templateId)}/source`);
+    }
+    /** `POST /templates/:id/source/copy`: create the editable copy from the published version and link it. */
+    async createSourceCopy(templateId) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/source/copy`, { body: {} });
+    }
+    /** `PATCH /templates/:id/review-policy` */
+    async setReviewPolicy(templateId, policy) {
+        return this.http.request('PATCH', `/templates/${(0, http_1.seg)(templateId)}/review-policy`, { body: policy });
+    }
+    // ─── Business settings the template asks for ─────────────────────────
+    /** `GET /templates/:id/config-fields` (open draft, else published). */
+    async configFields(templateId) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/config-fields`);
+    }
+    /** `PUT /templates/:id/config-fields` (saved on the open draft). 400 `invalid_config_schema` if malformed. */
+    async setConfigFields(templateId, configSchema) {
+        return this.http.request('PUT', `/templates/${(0, http_1.seg)(templateId)}/config-fields`, { body: { configSchema } });
+    }
+}
+exports.TemplatesResource = TemplatesResource;
+/** `forTenant(id).templates`: everything of `client.templates` plus the workspace-bound calls. */
+class TenantTemplatesResource extends TemplatesResource {
+    constructor(http, tenantId) {
+        super(http);
+        this.tenantId = tenantId;
+    }
+    get tenantBase() {
+        return `/admin/tenants/${(0, http_1.seg)(this.tenantId)}`;
+    }
+    /** `GET /templates?tenantId=`: system + public + this workspace's own. */
+    async list(input = {}) {
+        return this.http.request('GET', '/templates', { query: { tenantId: this.tenantId, ...listQuery(input) } });
+    }
+    /** `POST /templates/:id/install` into this workspace. */
+    async install(templateId, input = {}) {
+        return this.http.request('POST', `/templates/${(0, http_1.seg)(templateId)}/install`, {
+            body: { destinationTenantId: this.tenantId, ...input },
+        });
+    }
+    /** `GET /templates/:id/install-readiness?destinationTenantId=`: what is ready / needs setup before installing here. */
+    async installReadiness(templateId) {
+        return this.http.request('GET', `/templates/${(0, http_1.seg)(templateId)}/install-readiness`, {
+            query: { destinationTenantId: this.tenantId },
+        });
+    }
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/save-as-template` */
+    async saveAgentAsTemplate(agentId, input = {}) {
+        return this.http.request('POST', `${this.tenantBase}/agents/${(0, http_1.seg)(agentId)}/save-as-template`, { body: input });
+    }
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/save-as-template` */
+    async saveTeamAsTemplate(teamId, input = {}) {
+        return this.http.request('POST', `${this.tenantBase}/teams/${(0, http_1.seg)(teamId)}/save-as-template`, { body: input });
+    }
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/publish-template-version` */
+    async publishAgentTemplateVersion(agentId, input) {
+        return this.http.request('POST', `${this.tenantBase}/agents/${(0, http_1.seg)(agentId)}/publish-template-version`, {
+            body: input,
+        });
+    }
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/publish-template-version` */
+    async publishTeamTemplateVersion(teamId, input) {
+        return this.http.request('POST', `${this.tenantBase}/teams/${(0, http_1.seg)(teamId)}/publish-template-version`, {
+            body: input,
+        });
+    }
+    /** `GET /admin/tenants/:tenantId/teams/:teamId/template-source`: the template this team is the source of, with its version state. */
+    async templateSource(teamId) {
+        return this.http.request('GET', `${this.tenantBase}/teams/${(0, http_1.seg)(teamId)}/template-source`);
+    }
+    /** `GET /me/template-updates-available?tenantId=`: installed agents/teams behind their template. */
+    async updatesAvailable() {
+        return this.http.request('GET', '/me/template-updates-available', { query: { tenantId: this.tenantId } });
+    }
+    /** `POST /admin/tenants/:tenantId/teams/:teamId/update-from-template` */
+    async updateTeamFromTemplate(teamId, input = {}) {
+        return this.http.request('POST', `${this.tenantBase}/teams/${(0, http_1.seg)(teamId)}/update-from-template`, {
+            body: input,
+        });
+    }
+    /** `POST /admin/tenants/:tenantId/agents/:agentId/update-from-template` */
+    async updateAgentFromTemplate(agentId, input = {}) {
+        return this.http.request('POST', `${this.tenantBase}/agents/${(0, http_1.seg)(agentId)}/update-from-template`, {
+            body: input,
+        });
+    }
+}
+exports.TenantTemplatesResource = TenantTemplatesResource;

package/dist/resources/tenants.d.ts

@@ -0,0 +1,12 @@
+import type { HttpCore } from '../http';
+import type { CreateTenantInput, ListTenantsInput, Tenant, TenantList, UpdateTenantInput } from '../types';
+export declare class TenantsResource {
+    private readonly http;
+    constructor(http: HttpCore);
+    /** `GET /me/tenants` */
+    listMine(input?: ListTenantsInput): Promise<TenantList>;
+    /** `POST /admin/tenants`. The caller becomes the owner. */
+    create(input: CreateTenantInput): Promise<Tenant>;
+    /** `PATCH /admin/tenants/:tenantId` */
+    update(tenantId: string, patch: UpdateTenantInput): Promise<Tenant>;
+}

package/dist/resources/tenants.js

@@ -0,0 +1,25 @@
+"use strict";
+// tenants: the user's workspaces. `GET /me/tenants` (owned + member, with
+// `myRole`) feeds the switcher. The server has no `GET /admin/tenants/:id`:
+// read one from `listMine`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantsResource = void 0;
+const http_1 = require("../http");
+class TenantsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `GET /me/tenants` */
+    async listMine(input = {}) {
+        return this.http.request('GET', '/me/tenants', { query: { ...input } });
+    }
+    /** `POST /admin/tenants`. The caller becomes the owner. */
+    async create(input) {
+        return this.http.request('POST', '/admin/tenants', { body: input });
+    }
+    /** `PATCH /admin/tenants/:tenantId` */
+    async update(tenantId, patch) {
+        return this.http.request('PATCH', `/admin/tenants/${(0, http_1.seg)(tenantId)}`, { body: patch });
+    }
+}
+exports.TenantsResource = TenantsResource;

package/dist/resources/tools.d.ts

@@ -0,0 +1,13 @@
+import type { HttpCore } from '../http';
+import type { ToolGroup } from '../types';
+export declare class ToolsResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    /** `GET /tools/grouped?tenantId=&q=` */
+    grouped(input?: {
+        q?: string;
+    }): Promise<{
+        groups: ToolGroup[];
+    }>;
+}

package/dist/resources/tools.js

@@ -0,0 +1,17 @@
+"use strict";
+// tools: the tool catalog, grouped by source (connector / MCP / built-in).
+// `forTenant(id).tools`. Feeds the agent editor's tool picker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolsResource = void 0;
+class ToolsResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    /** `GET /tools/grouped?tenantId=&q=` */
+    async grouped(input = {}) {
+        const q = input.q?.trim();
+        return this.http.request('GET', '/tools/grouped', { query: { tenantId: this.tenantId, q: q || undefined } });
+    }
+}
+exports.ToolsResource = ToolsResource;

package/dist/resources/variables.d.ts

@@ -0,0 +1,28 @@
+import type { HttpCore } from '../http';
+import type { TenantVariable, UpsertTenantVariableInput } from '../types';
+export declare class VariablesResource {
+    private readonly http;
+    private readonly tenantId;
+    constructor(http: HttpCore, tenantId: string);
+    private get base();
+    /** `GET /tenants/:tenantId/variables?q=`. Members get config variables
+     *  (with `value`); owner/admin also get secrets (`valueHint` only). */
+    list(input?: {
+        q?: string;
+    }): Promise<{
+        items: TenantVariable[];
+    }>;
+    /** `GET .../variables/:key` (same visibility as the list; 404 when absent). */
+    get(key: string): Promise<TenantVariable>;
+    /** `PUT .../variables/:key`. Owner/admin only. `kind` omitted keeps the
+     *  current kind (new variables default to `secret`); turning an existing
+     *  secret into config is a 409 `variable_kind_conflict`. `value` is a
+     *  non-empty string of at most 10 000 characters. Resolves to the stored
+     *  entry: a secret comes back as a hint, never the value. */
+    upsert(key: string, input: UpsertTenantVariableInput): Promise<TenantVariable>;
+    /** `DELETE .../variables/:key`. Owner/admin only. 409 `has_bindings`
+     *  (details.bindings) unless `force`. */
+    remove(key: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+}

package/dist/resources/variables.js

@@ -0,0 +1,43 @@
+"use strict";
+// Workspace variables (`forTenant(id).variables`): business data a template
+// reads through `{{config:KEY}}` (config, readable) or `{{secret:KEY}}`
+// (secret, write-only: the platform only ever returns a 4-char hint).
+// Server: `TenantVariablesController` at `/tenants/:tenantId/variables`
+// (no `admin/` prefix: plain members read config).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariablesResource = void 0;
+const http_1 = require("../http");
+class VariablesResource {
+    constructor(http, tenantId) {
+        this.http = http;
+        this.tenantId = tenantId;
+    }
+    get base() {
+        return `/tenants/${(0, http_1.seg)(this.tenantId)}/variables`;
+    }
+    /** `GET /tenants/:tenantId/variables?q=`. Members get config variables
+     *  (with `value`); owner/admin also get secrets (`valueHint` only). */
+    async list(input = {}) {
+        return this.http.request('GET', this.base, { query: { q: input.q } });
+    }
+    /** `GET .../variables/:key` (same visibility as the list; 404 when absent). */
+    async get(key) {
+        return this.http.request('GET', `${this.base}/${(0, http_1.seg)(key)}`);
+    }
+    /** `PUT .../variables/:key`. Owner/admin only. `kind` omitted keeps the
+     *  current kind (new variables default to `secret`); turning an existing
+     *  secret into config is a 409 `variable_kind_conflict`. `value` is a
+     *  non-empty string of at most 10 000 characters. Resolves to the stored
+     *  entry: a secret comes back as a hint, never the value. */
+    async upsert(key, input) {
+        return this.http.request('PUT', `${this.base}/${(0, http_1.seg)(key)}`, { body: input });
+    }
+    /** `DELETE .../variables/:key`. Owner/admin only. 409 `has_bindings`
+     *  (details.bindings) unless `force`. */
+    async remove(key, options = {}) {
+        await this.http.request('DELETE', `${this.base}/${(0, http_1.seg)(key)}`, {
+            query: { force: options.force ? true : undefined },
+        });
+    }
+}
+exports.VariablesResource = VariablesResource;

package/dist/token-store.d.ts

@@ -0,0 +1,23 @@
+export type MaybePromise<T> = T | Promise<T>;
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface TokenStore {
+    getAccessToken(): MaybePromise<string | null>;
+    getRefreshToken(): MaybePromise<string | null>;
+    /** Persist a fresh pair (login, register, invite accept, refresh rotation). */
+    setTokens(tokens: AuthTokens): MaybePromise<void>;
+    /** Wipe both tokens (sign out). */
+    clear(): MaybePromise<void>;
+}
+/** In-memory store: tests, SSR, or an app that does not persist the session. */
+export declare class MemoryTokenStore implements TokenStore {
+    private access;
+    private refresh;
+    constructor(initial?: Partial<AuthTokens>);
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    setTokens(tokens: AuthTokens): void;
+    clear(): void;
+}

package/dist/token-store.js

@@ -0,0 +1,27 @@
+"use strict";
+// Where the session tokens live. The app plugs its own storage: SecureStore on
+// native, localStorage / memory on web. Every method may be sync or async.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTokenStore = void 0;
+/** In-memory store: tests, SSR, or an app that does not persist the session. */
+class MemoryTokenStore {
+    constructor(initial) {
+        this.access = initial?.accessToken ?? null;
+        this.refresh = initial?.refreshToken ?? null;
+    }
+    getAccessToken() {
+        return this.access;
+    }
+    getRefreshToken() {
+        return this.refresh;
+    }
+    setTokens(tokens) {
+        this.access = tokens.accessToken;
+        this.refresh = tokens.refreshToken;
+    }
+    clear() {
+        this.access = null;
+        this.refresh = null;
+    }
+}
+exports.MemoryTokenStore = MemoryTokenStore;