@fonoster/sdk 0.27.0 → 0.31.0

package/dist/node/Billing.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Billing = void 0;
+const makeRpcRequest_1 = require("./client/makeRpcRequest");
+const billing_pb_1 = require("./generated/node/billing_pb");
+/**
+ * @classdesc Fonoster Cloud's billing for the owner signed in: the balance in credits
+ * (1 credit = $0.01) by source, the plan, top-ups, auto-recharge and the Stripe Customer Portal.
+ * Only workspace owners may call it, and only on Fonoster Cloud (the capabilities say
+ * `billing.enabled`). The account is always the caller's: it covers every workspace they own.
+ *
+ * @example
+ * const billing = new SDK.Billing(client);
+ * const { balance, sources } = await billing.getBilling();
+ * await billing.createTopUp({ credits: 1000 });
+ */
+class Billing {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** The balance by source, the plan and auto-recharge. */
+    async getBilling() {
+        const client = this.client.getBillingClient();
+        return this.summary((0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.getBilling.bind(client),
+            requestPBObjectConstructor: billing_pb_1.GetBillingRequest,
+            metadata: this.client.getMetadata(),
+            request: {},
+            repeatableObjectMapping: [["sourcesList", billing_pb_1.CreditSource]]
+        }));
+    }
+    /** Turns auto-recharge on or off, with its threshold and amount in credits. */
+    async updateAutoRecharge(request) {
+        const client = this.client.getBillingClient();
+        return this.summary((0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.updateAutoRecharge.bind(client),
+            requestPBObjectConstructor: billing_pb_1.UpdateAutoRechargeRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["sourcesList", billing_pb_1.CreditSource]]
+        }));
+    }
+    /**
+     * Buys top-up credits, charged to the payment method added in the Customer Portal, with tax on
+     * top. The credits appear once the payment succeeds.
+     */
+    async createTopUp(request) {
+        const client = this.client.getBillingClient();
+        return this.summary((0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.createTopUp.bind(client),
+            requestPBObjectConstructor: billing_pb_1.CreateTopUpRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["sourcesList", billing_pb_1.CreditSource]]
+        }));
+    }
+    /** Moves the owner from the Trial to Pay-as-you-go. Needs a payment method first. */
+    async subscribe() {
+        const client = this.client.getBillingClient();
+        return this.summary((0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.subscribe.bind(client),
+            requestPBObjectConstructor: billing_pb_1.SubscribeRequest,
+            metadata: this.client.getMetadata(),
+            request: {},
+            repeatableObjectMapping: [["sourcesList", billing_pb_1.CreditSource]]
+        }));
+    }
+    /** A Stripe Customer Portal link for payment methods and invoices. */
+    async createPortalSession(request) {
+        const client = this.client.getBillingClient();
+        return (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.createPortalSession.bind(client),
+            requestPBObjectConstructor: billing_pb_1.CreatePortalSessionRequest,
+            metadata: this.client.getMetadata(),
+            request
+        });
+    }
+    async summary(raw) {
+        const { sources, ...rest } = await raw;
+        return { ...rest, sources: sources ?? [] };
+    }
+}
+exports.Billing = Billing;

package/dist/node/CallRecords.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CallRecordAuditEntry, CallRecordDetail, ListCallRecordsRequest, ListCallRecordsResponse, RetentionPolicy } from "@fonoster/types";
+import { FonosterClient } from "./client/types";
+type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    headers: {
+        get(name: string): string | null;
+    };
+    json(): Promise<unknown>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}>;
+/** An error answer from the records API (status and its `error` code). */
+declare class CallRecordsError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message?: string);
+}
+/**
+ * @classdesc Call records (vCon) through the HTTP records API (`/api/records`): search, one
+ * record (redacted unless you ask for the original and have the owner or admin role), the
+ * recording, the audit log, erasure and retention.
+ *
+ * @example
+ * const records = new SDK.CallRecords(client);
+ * const { items } = await records.listRecords({ after: "2026-10-01T00:00:00Z" });
+ * const record = await records.getRecord(items[0].callRef);
+ */
+declare class CallRecords {
+    private readonly client;
+    private readonly baseUrl?;
+    private readonly fetchFn;
+    /**
+     * @param {FonosterClient} client - A logged-in client
+     * @param {object} options - `baseUrl` of the HTTP API (default: the client's), `fetch`
+     */
+    constructor(client: FonosterClient, options?: {
+        baseUrl?: string;
+        fetch?: FetchLike;
+    });
+    private url;
+    /** Sends a request, refreshing the access token once on 401. */
+    private send;
+    private json;
+    /** Searches the workspace's records, newest first. */
+    listRecords(request?: ListCallRecordsRequest): Promise<ListCallRecordsResponse>;
+    /** One record; the latest version unless `version` is given. */
+    getRecord(callRef: string, options?: {
+        version?: number;
+        original?: boolean;
+    }): Promise<CallRecordDetail>;
+    /** The recording (WAV) with its content hash. */
+    getRecording(callRef: string, options?: {
+        version?: number;
+        original?: boolean;
+    }): Promise<{
+        data: ArrayBuffer;
+        contentType: string;
+        contentHash: string;
+    }>;
+    /** Deletions and erasures of a record (owner or admin). */
+    getAudit(callRef: string): Promise<CallRecordAuditEntry[]>;
+    /** Erases the call: every object is deleted and a signed tombstone remains (owner or admin). */
+    eraseRecord(callRef: string, reason?: string): Promise<unknown>;
+    /** Deletes one part (recording, transcript, messages) of a record (owner or admin). */
+    deletePart(callRef: string, part: string, reason?: string): Promise<unknown>;
+    getRetention(): Promise<RetentionPolicy[]>;
+    /** Sets how many days a part is kept; `null` removes the policy (owner or admin). */
+    setRetention(part: string, days: number | null): Promise<RetentionPolicy>;
+}
+export { CallRecords, CallRecordsError };

package/dist/node/CallRecords.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallRecordsError = exports.CallRecords = void 0;
+/** An error answer from the records API (status and its `error` code). */
+class CallRecordsError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message ?? `records API: ${status} ${code}`);
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.CallRecordsError = CallRecordsError;
+/**
+ * @classdesc Call records (vCon) through the HTTP records API (`/api/records`): search, one
+ * record (redacted unless you ask for the original and have the owner or admin role), the
+ * recording, the audit log, erasure and retention.
+ *
+ * @example
+ * const records = new SDK.CallRecords(client);
+ * const { items } = await records.listRecords({ after: "2026-10-01T00:00:00Z" });
+ * const record = await records.getRecord(items[0].callRef);
+ */
+class CallRecords {
+    client;
+    baseUrl;
+    fetchFn;
+    /**
+     * @param {FonosterClient} client - A logged-in client
+     * @param {object} options - `baseUrl` of the HTTP API (default: the client's), `fetch`
+     */
+    constructor(client, options = {}) {
+        this.client = client;
+        this.baseUrl = options.baseUrl?.replace(/\/+$/, "");
+        // Called as a method below, so never store the global unbound: in browsers a detached
+        // `fetch` throws "Illegal invocation".
+        this.fetchFn =
+            options.fetch ??
+                ((input, init) => globalThis.fetch(input, init));
+    }
+    url(path, query = {}) {
+        const base = this.baseUrl ?? this.client.getHttpUrl?.() ?? "https://api.fonoster.ai";
+        const qs = Object.entries(query)
+            .filter(([, v]) => v !== undefined && v !== null && v !== "")
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join("&");
+        return `${base}/api/records${path}${qs ? `?${qs}` : ""}`;
+    }
+    /** Sends a request, refreshing the access token once on 401. */
+    async send(path, init = {}) {
+        const attempt = () => this.fetchFn(this.url(path, init.query), {
+            method: init.method ?? "GET",
+            headers: {
+                authorization: `Bearer ${this.client.getAccessToken()}`,
+                "x-accesskey-id": this.client.getAccessKeyId(),
+                ...(init.body ? { "content-type": "application/json" } : {})
+            },
+            body: init.body ? JSON.stringify(init.body) : undefined
+        });
+        let res = await attempt();
+        if (res.status === 401) {
+            await this.client.refreshToken();
+            res = await attempt();
+        }
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            throw new CallRecordsError(res.status, body.error ?? "error", body.message);
+        }
+        return res;
+    }
+    async json(path, init) {
+        return (await (await this.send(path, init)).json());
+    }
+    /** Searches the workspace's records, newest first. */
+    async listRecords(request = {}) {
+        return this.json("", { query: request });
+    }
+    /** One record; the latest version unless `version` is given. */
+    async getRecord(callRef, options = {}) {
+        return this.json(`/${encodeURIComponent(callRef)}`, {
+            query: {
+                version: options.version,
+                original: options.original ? "true" : undefined
+            }
+        });
+    }
+    /** The recording (WAV) with its content hash. */
+    async getRecording(callRef, options = {}) {
+        const res = await this.send(`/${encodeURIComponent(callRef)}/recording`, {
+            query: {
+                version: options.version,
+                original: options.original ? "true" : undefined
+            }
+        });
+        return {
+            data: await res.arrayBuffer(),
+            contentType: res.headers.get("content-type") ?? "audio/x-wav",
+            contentHash: res.headers.get("x-content-hash") ?? ""
+        };
+    }
+    /** Deletions and erasures of a record (owner or admin). */
+    async getAudit(callRef) {
+        const { items } = await this.json(`/${encodeURIComponent(callRef)}/audit`);
+        return items;
+    }
+    /** Erases the call: every object is deleted and a signed tombstone remains (owner or admin). */
+    async eraseRecord(callRef, reason) {
+        return this.json(`/${encodeURIComponent(callRef)}`, {
+            method: "DELETE",
+            body: reason ? { reason } : undefined
+        });
+    }
+    /** Deletes one part (recording, transcript, messages) of a record (owner or admin). */
+    async deletePart(callRef, part, reason) {
+        return this.json(`/${encodeURIComponent(callRef)}/parts/${encodeURIComponent(part)}`, { method: "DELETE", body: reason ? { reason } : undefined });
+    }
+    async getRetention() {
+        const { items } = await this.json("/retention");
+        return items;
+    }
+    /** Sets how many days a part is kept; `null` removes the policy (owner or admin). */
+    async setRetention(part, days) {
+        return this.json("/retention", { method: "PUT", body: { part, days } });
+    }
+}
+exports.CallRecords = CallRecords;

package/dist/node/Calls.d.ts

@@ -126,13 +126,15 @@ declare class Calls {
      * @param {ListCallsRequest} request - The request object that contains the necessary information to retrieve a list of Calls
      * @param {number} request.pageSize - The number of Calls to retrieve
      * @param {string} request.pageToken - The token to retrieve the next page of Calls
+     * @param {string} request.appRef - Optional. Lists only the Calls the App with this reference handled
      * @return {Promise<ListCallsResponse>} - The response object that contains the list of Calls
      * @example
      * const calls = new SDK.Calls(client); // Existing client object
      *
      * const request = {
      *   pageSize: 10,
-     *   pageToken: "00000000-0000-0000-0000-000000000000"
+     *   pageToken: "00000000-0000-0000-0000-000000000000",
+     *   appRef: "00000000-0000-0000-0000-000000000000" // Optional: only this App's Calls
      * };
      *
      * calls

package/dist/node/Calls.js

@@ -175,13 +175,15 @@ class Calls {
      * @param {ListCallsRequest} request - The request object that contains the necessary information to retrieve a list of Calls
      * @param {number} request.pageSize - The number of Calls to retrieve
      * @param {string} request.pageToken - The token to retrieve the next page of Calls
+     * @param {string} request.appRef - Optional. Lists only the Calls the App with this reference handled
      * @return {Promise<ListCallsResponse>} - The response object that contains the list of Calls
      * @example
      * const calls = new SDK.Calls(client); // Existing client object
      *
      * const request = {
      *   pageSize: 10,
-     *   pageToken: "00000000-0000-0000-0000-000000000000"
+     *   pageToken: "00000000-0000-0000-0000-000000000000",
+     *   appRef: "00000000-0000-0000-0000-000000000000" // Optional: only this App's Calls
      * };
      *
      * calls

package/dist/node/Domains.js

@@ -86,7 +86,8 @@ class Domains {
             method: client.createDomain.bind(client),
             requestPBObjectConstructor: domains_pb_1.CreateDomainRequest,
             metadata: this.client.getMetadata(),
-            request
+            request,
+            objectMapping: [["egressPolicies", domains_pb_1.EgressPolicy]]
         });
     }
     /**
@@ -155,7 +156,8 @@ class Domains {
             method: client.updateDomain.bind(client),
             requestPBObjectConstructor: domains_pb_1.UpdateDomainRequest,
             metadata: this.client.getMetadata(),
-            request
+            request,
+            objectMapping: [["egressPolicies", domains_pb_1.EgressPolicy]]
         });
     }
     /**

package/dist/node/Numbers.js

@@ -110,13 +110,8 @@ class Numbers {
             metadata: this.client.getMetadata(),
             request: { ref }
         });
-        const trunk = response?.trunk?.toObject();
-        return response
-            ? {
-                ...response,
-                trunk
-            }
-            : null;
+        // The trunk comes back as a plain object (objectToJson).
+        return response ?? null;
     }
     /**
      * Updates an existing Number in the Workspace.

package/dist/node/Providers.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ListCatalogRequest, ListCatalogResponse, ListProviderKeysResponse, ListWarningsResponse, ProviderKey, SetProviderKeyRequest } from "@fonoster/types";
+import { FonosterClient } from "./client/types";
+/**
+ * @classdesc The provider catalog (read-only) and the workspace's own vendor keys. Catalog ids
+ * (`<provider>/<model-or-voice>`) are what apps use for speech defaults. A key is stored in a
+ * write-only Secret and never read back.
+ *
+ * @example
+ * const providers = new SDK.Providers(client);
+ * const { items } = await providers.listCatalog({ kind: "voice" });
+ * await providers.setProviderKey({ providerId: "deepgram", key: "dg-..." });
+ */
+declare class Providers {
+    private readonly client;
+    constructor(client: FonosterClient);
+    /** Providers, models and voices this workspace can use (not retired). */
+    listCatalog(request?: ListCatalogRequest): Promise<ListCatalogResponse>;
+    /** Stores or replaces the workspace's key for a provider. */
+    setProviderKey(request: SetProviderKeyRequest): Promise<ProviderKey>;
+    listProviderKeys(): Promise<ListProviderKeysResponse>;
+    /**
+     * Deprecated or retired catalog items this workspace uses, with the saved configs that name
+     * them and the apps whose sessions used them lately (the dashboard's warnings).
+     */
+    listWarnings(): Promise<ListWarningsResponse>;
+    /** Removes the workspace's key for a provider (the platform key applies again). */
+    deleteProviderKey(providerId: string): Promise<{
+        providerId: string;
+    }>;
+}
+export { Providers };

package/dist/node/Providers.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Providers = void 0;
+const makeRpcRequest_1 = require("./client/makeRpcRequest");
+const providers_pb_1 = require("./generated/node/providers_pb");
+/** Repeated fields come back as `xList` when empty; normalize them and drop empty strings. */
+function toItem(raw) {
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const name = key.endsWith("List") ? key.slice(0, -4) : key;
+        // Proto3 defaults: "" is unset, and keyless is false for anything but a keyless provider.
+        if (value === "" || (name === "keyless" && !value))
+            continue;
+        out[name] = value;
+    }
+    for (const list of ["capabilities", "languages", "features", "models"])
+        out[list] ??= [];
+    return out;
+}
+/**
+ * @classdesc The provider catalog (read-only) and the workspace's own vendor keys. Catalog ids
+ * (`<provider>/<model-or-voice>`) are what apps use for speech defaults. A key is stored in a
+ * write-only Secret and never read back.
+ *
+ * @example
+ * const providers = new SDK.Providers(client);
+ * const { items } = await providers.listCatalog({ kind: "voice" });
+ * await providers.setProviderKey({ providerId: "deepgram", key: "dg-..." });
+ */
+class Providers {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Providers, models and voices this workspace can use (not retired). */
+    async listCatalog(request = {}) {
+        const client = this.client.getProvidersClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.listCatalog.bind(client),
+            requestPBObjectConstructor: providers_pb_1.ListCatalogRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["itemsList", providers_pb_1.CatalogItem]]
+        });
+        return { items: (raw.items ?? []).map(toItem) };
+    }
+    /** Stores or replaces the workspace's key for a provider. */
+    async setProviderKey(request) {
+        const client = this.client.getProvidersClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.setProviderKey.bind(client),
+            requestPBObjectConstructor: providers_pb_1.SetProviderKeyRequest,
+            metadata: this.client.getMetadata(),
+            request
+        });
+    }
+    async listProviderKeys() {
+        const client = this.client.getProvidersClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.listProviderKeys.bind(client),
+            requestPBObjectConstructor: providers_pb_1.ListProviderKeysRequest,
+            metadata: this.client.getMetadata(),
+            request: {},
+            repeatableObjectMapping: [["itemsList", providers_pb_1.ProviderKey]]
+        });
+        return { items: raw.items ?? [] };
+    }
+    /**
+     * Deprecated or retired catalog items this workspace uses, with the saved configs that name
+     * them and the apps whose sessions used them lately (the dashboard's warnings).
+     */
+    async listWarnings() {
+        const client = this.client.getProvidersClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.listWarnings.bind(client),
+            requestPBObjectConstructor: providers_pb_1.ListWarningsRequest,
+            metadata: this.client.getMetadata(),
+            request: {},
+            repeatableObjectMapping: [["itemsList", providers_pb_1.Warning]]
+        });
+        return {
+            items: (raw.items ?? []).map((w) => {
+                const out = {};
+                for (const [key, value] of Object.entries(w)) {
+                    const name = key.endsWith("List") ? key.slice(0, -4) : key;
+                    // Proto3 defaults: "" is unset, and keyless is false for anything but a keyless provider.
+                    if (value === "" || (name === "keyless" && !value))
+                        continue;
+                    out[name] = value;
+                }
+                out.usedBy ??= [];
+                out.runtimeApps ??= [];
+                out.runtimeSessions ??= 0;
+                return out;
+            })
+        };
+    }
+    /** Removes the workspace's key for a provider (the platform key applies again). */
+    async deleteProviderKey(providerId) {
+        const client = this.client.getProvidersClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.deleteProviderKey.bind(client),
+            requestPBObjectConstructor: providers_pb_1.DeleteProviderKeyRequest,
+            metadata: this.client.getMetadata(),
+            request: { providerId }
+        });
+    }
+}
+exports.Providers = Providers;

package/dist/node/Regions.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CreateRegionRequest, CreateRegionResponse, ListRegionsResponse, Region, RegionEnrollmentToken } from "@fonoster/types";
+import { FonosterClient } from "./client/types";
+type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+/** An error answer from the regions API (status and its `error` code). */
+declare class RegionsError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message?: string);
+}
+/**
+ * @classdesc Regions (add-private-regions, PR-12..PR-21) through the HTTP API (`/api/regions`).
+ * Regions belong to the signed-in user: create a private region (id, display name, SIP domain),
+ * get its one-time enrollment token, watch its status, re-issue the token, disconnect or delete
+ * it. A workspace picks a region when it is created (`workspaces.createWorkspace({name, region})`).
+ *
+ * @example
+ * const regions = new SDK.Regions(client);
+ * const { items } = await regions.listRegions();
+ * const { ref, token } = await regions.createRegion({
+ *   id: "acme-hq", displayName: "Acme HQ", sipDomain: "sip.acme.com"
+ * });
+ * const region = await regions.getRegion("acme-hq");
+ */
+declare class Regions {
+    private readonly client;
+    private readonly baseUrl?;
+    private readonly fetchFn;
+    constructor(client: FonosterClient, options?: {
+        baseUrl?: string;
+        fetch?: FetchLike;
+    });
+    private headers;
+    private json;
+    private static path;
+    /**
+     * The regions a new workspace can pick: the offered public regions and, when signed in, your
+     * private regions (with status).
+     */
+    listRegions(): Promise<ListRegionsResponse>;
+    /**
+     * Creates a private region (PR-15, PR-16, PR-18). The token (`token`, also `enrollmentToken`)
+     * is returned once; run `fonoster-region enroll <token>` on the region machine.
+     */
+    createRegion(request: CreateRegionRequest): Promise<CreateRegionResponse>;
+    /**
+     * One region by id or ref; without an argument, the current workspace's region (its status,
+     * secrets and connection details).
+     */
+    getRegion(region?: string): Promise<Region>;
+    /** Changes a private region's display name (the id never changes). */
+    updateRegion(region: string, request: {
+        displayName: string;
+    }): Promise<Region>;
+    /** A new one-time enrollment token; enrolling with it revokes the current cell. */
+    reissueRegionToken(region?: string): Promise<RegionEnrollmentToken>;
+    /** Revokes the region's cell now; the region goes back to `waiting`. */
+    disconnectRegion(region?: string): Promise<void>;
+    /** Deletes a private region; refused (`region_in_use`) while any workspace uses it. */
+    deleteRegion(region: string): Promise<{
+        ref: string;
+    }>;
+    /** The given region, or the current workspace's region. */
+    private refOf;
+}
+export { Regions, RegionsError };