@fonoster/sdk 0.26.0 → 0.30.0

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/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,107 @@
+"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;
+        if (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;
+                    if (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 };

package/dist/node/Regions.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionsError = exports.Regions = void 0;
+/** An error answer from the regions API (status and its `error` code). */
+class RegionsError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message ?? `regions API: ${status} ${code}`);
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.RegionsError = RegionsError;
+/**
+ * @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");
+ */
+class Regions {
+    client;
+    baseUrl;
+    fetchFn;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.baseUrl = options.baseUrl?.replace(/\/+$/, "");
+        this.fetchFn =
+            options.fetch ?? globalThis.fetch;
+    }
+    headers(auth, body) {
+        const h = {};
+        if (body !== undefined)
+            h["content-type"] = "application/json";
+        if (!auth)
+            return h;
+        const token = this.client.getAccessToken?.();
+        if (token)
+            h.authorization = `Bearer ${token}`;
+        const accessKeyId = this.client.getAccessKeyId?.();
+        if (accessKeyId)
+            h["x-accesskey-id"] = accessKeyId;
+        return h;
+    }
+    async json(path, method = "GET", body, auth = true) {
+        const base = this.baseUrl ?? this.client.getHttpUrl?.() ?? "https://api.fonoster.com";
+        const attempt = () => this.fetchFn(`${base}/api/regions${path}`, {
+            method,
+            headers: this.headers(auth, body),
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {})
+        });
+        let res = await attempt();
+        if (res.status === 401 && auth) {
+            await this.client.refreshToken();
+            res = await attempt();
+        }
+        const out = (await res.json().catch(() => ({})));
+        if (!res.ok)
+            throw new RegionsError(res.status, String(out.error ?? "error"), out.message);
+        return out;
+    }
+    static path(region) {
+        return `/${encodeURIComponent(region)}`;
+    }
+    /**
+     * The regions a new workspace can pick: the offered public regions and, when signed in, your
+     * private regions (with status).
+     */
+    async listRegions() {
+        let signedIn = false;
+        try {
+            signedIn = !!this.client.getAccessToken?.();
+        }
+        catch {
+            signedIn = false;
+        }
+        return this.json("", "GET", undefined, signedIn);
+    }
+    /**
+     * 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.
+     */
+    async createRegion(request) {
+        return this.json("", "POST", request);
+    }
+    /**
+     * One region by id or ref; without an argument, the current workspace's region (its status,
+     * secrets and connection details).
+     */
+    async getRegion(region) {
+        return this.json(region ? Regions.path(region) : "/current");
+    }
+    /** Changes a private region's display name (the id never changes). */
+    async updateRegion(region, request) {
+        return this.json(Regions.path(region), "PATCH", request);
+    }
+    /** A new one-time enrollment token; enrolling with it revokes the current cell. */
+    async reissueRegionToken(region) {
+        return this.json(`${Regions.path(await this.refOf(region))}/token`, "POST");
+    }
+    /** Revokes the region's cell now; the region goes back to `waiting`. */
+    async disconnectRegion(region) {
+        await this.json(`${Regions.path(await this.refOf(region))}/disconnect`, "POST");
+    }
+    /** Deletes a private region; refused (`region_in_use`) while any workspace uses it. */
+    async deleteRegion(region) {
+        return this.json(Regions.path(region), "DELETE");
+    }
+    /** The given region, or the current workspace's region. */
+    async refOf(region) {
+        if (region)
+            return region;
+        return (await this.getRegion()).ref;
+    }
+}
+exports.Regions = Regions;

package/dist/node/Users.d.ts

@@ -117,7 +117,8 @@ declare class Users {
      * @param {UpdateUserRequest} request - The request object that contains the necessary information to update a User
      * @param {string} request.ref - The reference of the User to update
      * @param {string} [request.name] - The name of the User
-     * @param {string} [request.password] - The password of the User
+     * @param {string} [request.password] - A new password for the User; requires currentPassword and signs the User out everywhere
+     * @param {string} [request.currentPassword] - The User's current password, required to set a new one
      * @param {string} [request.avatar] - The avatar of the User
      * @param {string} [request.phone] - The phone number of the User (optional)
      * @return {Promise<BaseApiObject>} - The response object that contains the reference to the updated User
@@ -127,7 +128,8 @@ declare class Users {
      * const request = {
      *   ref: "00000000-0000-0000-0000-000000000000",
      *   name: "John Doe",
-     *   password: "password",
+     *   password: "a-new-password",
+     *   currentPassword: "the-current-password",
      *   avatar: "https://example.com/avatar.jpg",
      *   phone: "+1234567890"
      * };

package/dist/node/Users.js

@@ -128,7 +128,8 @@ class Users {
      * @param {UpdateUserRequest} request - The request object that contains the necessary information to update a User
      * @param {string} request.ref - The reference of the User to update
      * @param {string} [request.name] - The name of the User
-     * @param {string} [request.password] - The password of the User
+     * @param {string} [request.password] - A new password for the User; requires currentPassword and signs the User out everywhere
+     * @param {string} [request.currentPassword] - The User's current password, required to set a new one
      * @param {string} [request.avatar] - The avatar of the User
      * @param {string} [request.phone] - The phone number of the User (optional)
      * @return {Promise<BaseApiObject>} - The response object that contains the reference to the updated User
@@ -138,7 +139,8 @@ class Users {
      * const request = {
      *   ref: "00000000-0000-0000-0000-000000000000",
      *   name: "John Doe",
-     *   password: "password",
+     *   password: "a-new-password",
+     *   currentPassword: "the-current-password",
      *   avatar: "https://example.com/avatar.jpg",
      *   phone: "+1234567890"
      * };

package/dist/node/Webhooks.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { BaseApiObject, CreateWebhookRequest, CreateWebhookResponse, ListWebhookDeliveriesRequest, ListWebhookDeliveriesResponse, ListWebhooksRequest, ListWebhooksResponse, RotateWebhookSecretResponse, UpdateWebhookRequest, Webhook, WebhookDelivery } from "@fonoster/types";
+import { FonosterClient } from "./client/types";
+/**
+ * @classdesc Fonoster Webhooks, a capability of Fonoster's Workspaces. Webhooks receive call
+ * events (call.started, call.ended, call.failed, call_record.sealed, provider.deprecated),
+ * signed with the endpoint's secret.
+ *
+ * @example
+ * const SDK = require("@fonoster/sdk");
+ *
+ * async function main() {
+ *   const client = new SDK.Client({ accessKeyId: "WO00000000000000000000000000000000" });
+ *   await client.loginWithApiKey("APXXXXXXXXXXXXXXXX", "YYYYYYYYYYYYYYYYY");
+ *   const webhooks = new SDK.Webhooks(client);
+ *   const { ref, secret } = await webhooks.createWebhook({
+ *     url: "https://example.com/fonoster",
+ *     events: ["call.ended"]
+ *   });
+ * }
+ */
+declare class Webhooks {
+    private readonly client;
+    constructor(client: FonosterClient);
+    /** Creates an endpoint. The secret is returned only here and on rotation. */
+    createWebhook(request: CreateWebhookRequest): Promise<CreateWebhookResponse>;
+    getWebhook(ref: string): Promise<Webhook>;
+    listWebhooks(request?: ListWebhooksRequest): Promise<ListWebhooksResponse>;
+    /** Changes the URL and/or events; fields left out are kept. */
+    updateWebhook(request: UpdateWebhookRequest): Promise<BaseApiObject>;
+    deleteWebhook(ref: string): Promise<BaseApiObject>;
+    /** A new secret; the previous one keeps verifying for 24 hours. */
+    rotateWebhookSecret(ref: string): Promise<RotateWebhookSecretResponse>;
+    /** The delivery log, newest first (optionally one endpoint's). */
+    listWebhookDeliveries(request?: ListWebhookDeliveriesRequest): Promise<ListWebhookDeliveriesResponse>;
+    /** Sends a delivery again now, with the same event id and a fresh signature. */
+    resendWebhookDelivery(ref: string): Promise<WebhookDelivery>;
+}
+export { Webhooks };

package/dist/node/Webhooks.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = void 0;
+const makeRpcRequest_1 = require("./client/makeRpcRequest");
+const webhooks_pb_1 = require("./generated/node/webhooks_pb");
+const date = (seconds) => typeof seconds === "number" && seconds > 0
+    ? new Date(seconds * 1000)
+    : undefined;
+function toWebhook(raw) {
+    const { eventsList, previousSecretUntil, ...rest } = raw;
+    return {
+        ...rest,
+        events: (raw.events ?? eventsList ?? []),
+        previousSecretUntil: date(previousSecretUntil)
+    };
+}
+function toDelivery(raw) {
+    return {
+        ...raw,
+        lastAttemptAt: date(raw.lastAttemptAt),
+        nextAttemptAt: date(raw.nextAttemptAt)
+    };
+}
+/**
+ * @classdesc Fonoster Webhooks, a capability of Fonoster's Workspaces. Webhooks receive call
+ * events (call.started, call.ended, call.failed, call_record.sealed, provider.deprecated),
+ * signed with the endpoint's secret.
+ *
+ * @example
+ * const SDK = require("@fonoster/sdk");
+ *
+ * async function main() {
+ *   const client = new SDK.Client({ accessKeyId: "WO00000000000000000000000000000000" });
+ *   await client.loginWithApiKey("APXXXXXXXXXXXXXXXX", "YYYYYYYYYYYYYYYYY");
+ *   const webhooks = new SDK.Webhooks(client);
+ *   const { ref, secret } = await webhooks.createWebhook({
+ *     url: "https://example.com/fonoster",
+ *     events: ["call.ended"]
+ *   });
+ * }
+ */
+class Webhooks {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Creates an endpoint. The secret is returned only here and on rotation. */
+    async createWebhook(request) {
+        const client = this.client.getWebhooksClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.createWebhook.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.CreateWebhookRequest,
+            metadata: this.client.getMetadata(),
+            request
+        });
+    }
+    async getWebhook(ref) {
+        const client = this.client.getWebhooksClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.getWebhook.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.GetWebhookRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+        return toWebhook(raw);
+    }
+    async listWebhooks(request = {}) {
+        const client = this.client.getWebhooksClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.listWebhooks.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.ListWebhooksRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["itemsList", webhooks_pb_1.Webhook]]
+        });
+        return {
+            items: (raw.items ?? []).map(toWebhook),
+            nextPageToken: raw.nextPageToken
+        };
+    }
+    /** Changes the URL and/or events; fields left out are kept. */
+    async updateWebhook(request) {
+        const client = this.client.getWebhooksClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.updateWebhook.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.UpdateWebhookRequest,
+            metadata: this.client.getMetadata(),
+            request
+        });
+    }
+    async deleteWebhook(ref) {
+        const client = this.client.getWebhooksClient();
+        return await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.deleteWebhook.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.DeleteWebhookRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+    }
+    /** A new secret; the previous one keeps verifying for 24 hours. */
+    async rotateWebhookSecret(ref) {
+        const client = this.client.getWebhooksClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.rotateWebhookSecret.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.RotateWebhookSecretRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+        return {
+            ref: raw.ref,
+            secret: raw.secret,
+            previousSecretUntil: date(raw.previousSecretUntil)
+        };
+    }
+    /** The delivery log, newest first (optionally one endpoint's). */
+    async listWebhookDeliveries(request = {}) {
+        const client = this.client.getWebhooksClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.listWebhookDeliveries.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.ListWebhookDeliveriesRequest,
+            metadata: this.client.getMetadata(),
+            request,
+            repeatableObjectMapping: [["itemsList", webhooks_pb_1.WebhookDelivery]]
+        });
+        return { items: (raw.items ?? []).map(toDelivery) };
+    }
+    /** Sends a delivery again now, with the same event id and a fresh signature. */
+    async resendWebhookDelivery(ref) {
+        const client = this.client.getWebhooksClient();
+        const raw = await (0, makeRpcRequest_1.makeRpcRequest)({
+            method: client.resendWebhookDelivery.bind(client),
+            requestPBObjectConstructor: webhooks_pb_1.ResendWebhookDeliveryRequest,
+            metadata: this.client.getMetadata(),
+            request: { ref }
+        });
+        return toDelivery(raw);
+    }
+}
+exports.Webhooks = Webhooks;

package/dist/node/Workspaces.d.ts

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BaseApiObject, CreateWorkspaceRequest, InviteUserToWorkspaceRequest, ListWorkspaceMembersRequest, ListWorkspaceMembersResponse, ListWorkspacesResponse, RemoveUserFromWorkspaceResponse, ResendWorkspaceMembershipInvitationResponse, UpdateWorkspaceRequest, Workspace } from "@fonoster/types";
+import { BaseApiObject, CreateWorkspaceRequest, CreateWorkspaceResponse, InviteUserToWorkspaceRequest, ListWorkspaceMembersRequest, ListWorkspaceMembersResponse, ListWorkspacesResponse, Region, RegionEnrollmentToken, RemoveUserFromWorkspaceResponse, ResendWorkspaceMembershipInvitationResponse, UpdateWorkspaceRequest, Workspace } from "@fonoster/types";
 import { FonosterClient } from "./client/types";
 /**
  * @classdesc Fonoster Workspaces, part of the Fonoster Identity subsystem,
@@ -66,7 +66,8 @@ declare class Workspaces {
      *
      * @param {CreateWorkspaceRequest} request - The request object that contains the necessary information to create a new Workspace
      * @param {string} request.name - The name of the Workspace
-     * @return {Promise<BaseApiObject>} - The response object that contains the reference to the created Workspace
+     * @param {string} request.region - An offered public region id (default `default`) or one of your private regions (id or ref, see `Regions.createRegion`); fixed for life
+     * @return {Promise<CreateWorkspaceResponse>} - The reference and the stored region
      * @example
      * const workspaces = new SDK.Workspaces(client); // Existing client object
      *
@@ -79,7 +80,25 @@ declare class Workspaces {
      *   .then(console.log) // successful response
      *   .catch(console.error); // an error occurred
      */
-    createWorkspace(request: CreateWorkspaceRequest): Promise<BaseApiObject>;
+    createWorkspace(request: CreateWorkspaceRequest): Promise<CreateWorkspaceResponse>;
+    /**
+     * The current workspace's region (add-private-regions): for a private region, the cell's status,
+     * version, components, active calls and which secrets it needs and has.
+     *
+     * @return {Promise<Region>} - The region view
+     */
+    getRegion(): Promise<Region>;
+    /**
+     * Issues a new one-time enrollment token for the current workspace's region (its owner only).
+     * Enrolling a cell with it revokes the previous cell's credentials.
+     *
+     * @return {Promise<RegionEnrollmentToken>} - The token (shown once) and its expiry
+     */
+    reissueRegionToken(): Promise<RegionEnrollmentToken>;
+    /**
+     * Revokes the current workspace's region cell now; it goes back to `waiting` (region owner).
+     */
+    disconnectRegion(): Promise<void>;
     /**
      * Retrieves an existing Workspace in the system.
      *