sipgate-mcp 0.3.0 → 0.5.0

package/dist/backend/sipgate-backend.js

@@ -1,5 +1,5 @@
 import { SipgateApiError, SipgateClient } from "./sipgate-client.js";
-const SENSITIVE_KEY = /authorization|credential|password|secret|token/i;
+const SENSITIVE_KEY = /authorization|credential|password|secret|token|puk\d?|iccid/i;
 function sanitize(value) {
     if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
         return value;
@@ -17,13 +17,117 @@ function asItems(value) {
     const items = value.items;
     return Array.isArray(items) ? items : [];
 }
+function asCalls(value) {
+    if (!value || Array.isArray(value) || typeof value !== "object")
+        return [];
+    return Array.isArray(value.data)
+        ? value.data.filter((item) => Boolean(item) && !Array.isArray(item) && typeof item === "object")
+        : [];
+}
 function stringField(value, key) {
     const field = value[key];
     return typeof field === "string" ? field : undefined;
 }
+/**
+ * Account-wide writes are confirmed at the access boundary, but SipgateBackend
+ * is exported on its own, so the invariant is repeated here rather than trusted.
+ */
+function assertConfirmed(confirmed, action) {
+    if (confirmed === true)
+        return;
+    throw new SipgateApiError(`Refusing to ${action} without an explicit account-wide confirmation.`, 400);
+}
+/**
+ * Webhook URLs routinely carry their authentication in the query string, and
+ * the log returns them as plain strings that key-based redaction cannot see.
+ */
+function stripUrlQueries(value) {
+    if (typeof value === "string") {
+        const separator = value.indexOf("?");
+        return value.startsWith("http") && separator !== -1
+            ? `${value.slice(0, separator)}?[REDACTED]`
+            : value;
+    }
+    if (Array.isArray(value))
+        return value.map(stripUrlQueries);
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, stripUrlQueries(child)]));
+    }
+    return value;
+}
 function encodeId(id) {
     return encodeURIComponent(id);
 }
+function unavailableNote(status, subject) {
+    if (status === 403) {
+        return `sipgate denied access to ${subject} (HTTP 403). Either this account does not provide it, or the Personal Access Token lacks the scope for it.`;
+    }
+    if (status === 404) {
+        return `sipgate reports no ${subject} for this account (HTTP 404).`;
+    }
+    return `This sipgate account does not provide ${subject}.`;
+}
+function phonelineUnavailable(items = false, status) {
+    return {
+        ...(items ? { items: [] } : {}),
+        phonelinesAvailable: false,
+        ...(status === undefined ? {} : { httpStatus: status }),
+        note: unavailableNote(status, "the phoneline feature"),
+    };
+}
+function phonelineMutationUnavailable(status) {
+    return {
+        before: null,
+        after: {
+            changed: false,
+            phonelinesAvailable: false,
+            ...(status === undefined ? {} : { httpStatus: status }),
+            note: `${unavailableNote(status, "the phoneline feature")} No change was attempted.`,
+        },
+    };
+}
+function unavailableFeature(subject, status, items = false) {
+    return {
+        ...(items ? { items: [] } : {}),
+        available: false,
+        ...(status === undefined ? {} : { httpStatus: status }),
+        note: unavailableNote(status, subject),
+    };
+}
+function unavailableFeatureMutation(subject, status) {
+    return {
+        before: null,
+        after: {
+            changed: false,
+            ...unavailableFeature(subject, status),
+            note: `${unavailableNote(status, subject)} No change was attempted.`,
+        },
+    };
+}
+/**
+ * sipgate answers 403/404 for endpoints an account does not provide. Newer
+ * accounts have no phoneline layer at all: their numbers hang directly off a
+ * device. Treat those statuses as "feature absent" instead of a hard failure so
+ * a missing phoneline layer cannot take down number, history, and settings
+ * lookups that can be served from devices instead.
+ */
+const UNAVAILABLE_STATUS = new Set([403, 404]);
+async function optional(request) {
+    try {
+        return { value: await request, available: true };
+    }
+    catch (error) {
+        if (error instanceof SipgateApiError
+            && error.status !== undefined
+            && UNAVAILABLE_STATUS.has(error.status)) {
+            return { available: false, status: error.status };
+        }
+        throw error;
+    }
+}
+function idSet(items) {
+    return new Set(items.map((item) => stringField(item, "id")).filter((id) => Boolean(id)));
+}
 export class SipgateBackend {
     client;
     constructor(client) {
@@ -61,11 +165,120 @@ export class SipgateBackend {
         return sanitize({ items, pagination: { offset, limit, returned: items.length } });
     }
     async listPhonelines(userId) {
-        const response = await this.client.request(`/${encodeId(userId)}/phonelines`);
+        const { value, available } = await this.tryListPhonelines(userId);
+        if (!available)
+            return { items: [], phonelinesAvailable: false };
+        return sanitize(value ?? { items: [] });
+    }
+    tryListPhonelines(userId) {
+        return optional(this.client.request(`/${encodeId(userId)}/phonelines`));
+    }
+    phonelinePath(userId, phonelineId, suffix = "") {
+        return `/${encodeId(userId)}/phonelines/${encodeId(phonelineId)}${suffix}`;
+    }
+    async optionalPhonelineRead(path, list = false) {
+        const { value, available, status } = await optional(this.client.request(path));
+        return available ? sanitize(value ?? (list ? { items: [] } : {})) : phonelineUnavailable(list, status);
+    }
+    getPhoneline(userId, phonelineId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId));
+    }
+    getPhonelineBlockAnonymous(userId, phonelineId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId, "/blockanonymous"));
+    }
+    listPhonelineDevices(userId, phonelineId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId, "/devices"), true);
+    }
+    listParallelForwardings(userId, phonelineId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId, "/parallelforwardings"), true);
+    }
+    listPhonelineVoicemails(userId, phonelineId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId, "/voicemails"), true);
+    }
+    listVoicemailGreetings(userId, phonelineId, voicemailId) {
+        return this.optionalPhonelineRead(this.phonelinePath(userId, phonelineId, `/voicemails/${encodeId(voicemailId)}/greetings`), true);
+    }
+    async listVoicemails() {
+        const response = await this.client.request("/voicemails");
         return sanitize(response ?? { items: [] });
     }
+    async getVoicemail(voicemailId) {
+        const response = await this.client.request(`/voicemails/${encodeId(voicemailId)}`);
+        return sanitize(response ?? {});
+    }
+    async listAutorecordingGreetings() {
+        const { value, available } = await optional(this.client.request("/autorecordings/greetings"));
+        return available
+            ? sanitize(value ?? {})
+            : {
+                autorecordingsAvailable: false,
+                note: "Automated call recording is not activated for this sipgate account.",
+            };
+    }
+    async getAutorecordingSettings(extension) {
+        const { value, available } = await optional(this.client.request(`/autorecordings/${encodeId(extension)}/settings`));
+        return available
+            ? sanitize(value ?? {})
+            : {
+                autorecordingsAvailable: false,
+                note: "Automated call recording is not activated for this extension.",
+            };
+    }
+    async listDeviceIds(userId) {
+        const response = await this.client.request(`/${encodeId(userId)}/devices`);
+        return idSet(asItems(response));
+    }
+    /**
+     * Fallback for accounts without a phoneline layer: numbers are matched to the
+     * user through the device their endpoint points at.
+     */
+    async listAllAccountNumbers() {
+        const pageSize = 1000;
+        const all = [];
+        for (let offset = 0;; offset += pageSize) {
+            const response = await this.client.request("/numbers", {
+                query: { offset, limit: pageSize },
+            });
+            const page = asItems(response);
+            all.push(...page);
+            const envelope = response && !Array.isArray(response) && typeof response === "object"
+                ? response
+                : {};
+            const totalCount = typeof envelope.totalCount === "number" ? envelope.totalCount : undefined;
+            // sipgate may clamp the requested limit, so advance by what it actually
+            // returned and stop once a page comes back empty or the count is reached.
+            if (page.length === 0)
+                break;
+            if (totalCount !== undefined && all.length >= totalCount)
+                break;
+            if (page.length < pageSize)
+                break;
+        }
+        return all;
+    }
+    async listDeviceNumbers(userId, { offset, limit }, phonelinesAvailable) {
+        const [deviceIds, accountNumbers] = await Promise.all([
+            this.listDeviceIds(userId),
+            this.listAllAccountNumbers(),
+        ]);
+        const owned = accountNumbers.filter((number) => {
+            const endpointId = stringField(number, "endpointId");
+            return endpointId !== undefined && deviceIds.has(endpointId);
+        });
+        const page = owned.slice(offset, offset + limit);
+        return sanitize({
+            items: page,
+            pagination: { offset, limit, returned: page.length, totalCount: owned.length },
+            source: "devices",
+            phonelinesAvailable,
+        });
+    }
     async listUserNumbers(userId, { offset, limit }) {
-        const phonelines = asItems(await this.listPhonelines(userId));
+        const { value: phonelinesValue, available } = await this.tryListPhonelines(userId);
+        const phonelines = asItems(phonelinesValue);
+        if (!available || phonelines.length === 0) {
+            return this.listDeviceNumbers(userId, { offset, limit }, available);
+        }
         const numberGroups = await Promise.all(phonelines.map(async (phoneline) => {
             const phonelineId = stringField(phoneline, "id");
             if (!phonelineId)
@@ -87,6 +300,10 @@ export class SipgateBackend {
             pagination: { offset, limit, returned: page.length, totalCount: uniqueNumbers.length },
         });
     }
+    async getUserNumbers(userId) {
+        const response = await this.client.request(`/${encodeId(userId)}/numbers`);
+        return sanitize(response ?? { items: [] });
+    }
     async listDevices(userId, types) {
         const userIds = userId ? [userId] : asItems(await this.client.request("/users"))
             .map((user) => stringField(user, "id"))
@@ -99,6 +316,104 @@ export class SipgateBackend {
         const items = responses.flatMap(({ userId: ownerId, response }) => asItems(response).map((device) => ({ ...device, userId: ownerId })));
         return sanitize({ items });
     }
+    async getDevice(deviceId) {
+        const response = await this.client.request(`/devices/${encodeId(deviceId)}`);
+        return sanitize(response ?? {});
+    }
+    async getDeviceCallerId(deviceId) {
+        const response = await this.client.request(`/devices/${encodeId(deviceId)}/callerid`);
+        return sanitize(response ?? {});
+    }
+    async getDeviceLocalPrefix(deviceId) {
+        const response = await this.client.request(`/devices/${encodeId(deviceId)}/localprefix`);
+        return sanitize(response ?? {});
+    }
+    async getDeviceTariffAnnouncement(deviceId) {
+        const response = await this.client.request(`/devices/${encodeId(deviceId)}/tariffannouncement`);
+        return sanitize(response ?? {});
+    }
+    async getDeviceSingleRowDisplay(deviceId) {
+        const response = await this.client.request(`/devices/${encodeId(deviceId)}/singlerowdisplay`);
+        return sanitize(response ?? {});
+    }
+    async getDeviceContingents(userId, deviceId) {
+        const response = await this.client.request(`/${encodeId(userId)}/devices/${encodeId(deviceId)}/contingents`);
+        return sanitize(response ?? { contingents: [] });
+    }
+    async listAddresses() {
+        const response = await this.client.request("/addresses");
+        return sanitize(response ?? { items: [] });
+    }
+    async getAddress(addressId) {
+        const response = await this.client.request(`/addresses/${addressId}`);
+        return sanitize(response ?? {});
+    }
+    async listAddressNumbers(addressId) {
+        const response = await this.client.request(`/addresses/${addressId}/numbers`);
+        return sanitize(response ?? { items: [] });
+    }
+    async validateQuickDialNumber(quickDialNumber) {
+        const response = await this.client.request(`/numbers/quickdial/validation/${encodeId(quickDialNumber)}`);
+        return sanitize(response ?? {});
+    }
+    async listContacts(query) {
+        const response = await this.client.request("/contacts", {
+            query: {
+                phonenumbers: query.phoneNumbers,
+                limit: query.limit,
+                offset: query.offset,
+                lastId: query.lastId,
+                scopes: query.scopes,
+            },
+        });
+        return sanitize(response ?? { items: [], totalCount: 0 });
+    }
+    async getContact(contactId) {
+        const response = await this.client.request(`/contacts/${encodeId(contactId)}`);
+        return sanitize(response ?? {});
+    }
+    async listInternalContacts() {
+        const response = await this.client.request("/contacts/internal");
+        return sanitize(response ?? { items: [] });
+    }
+    async exportContactsCsv(scopes) {
+        const content = await this.client.requestText("/contacts/csv", {
+            query: { scope: scopes },
+            accept: "text/csv",
+        });
+        return { content, contentType: "text/csv" };
+    }
+    async getContactsVcard(query) {
+        const response = await this.client.request("/contacts/vcard", {
+            query: {
+                scope: query.scopes,
+                labels: query.labels,
+                contactIds: query.contactIds,
+                wantedFields: query.wantedFields,
+                filter: query.filter,
+                limit: query.limit,
+                offset: query.offset,
+                lastId: query.lastId,
+            },
+        });
+        return sanitize(response ?? { contacts: [], overallMatches: 0 });
+    }
+    async listIncomingBlacklist() {
+        const response = await this.client.request("/blacklist/incoming");
+        return sanitize(response ?? { items: [] });
+    }
+    async getCallRestrictions(userIds) {
+        const response = await this.client.request("/callrestrictions", {
+            query: { userIds },
+        });
+        return sanitize(response ?? {});
+    }
+    async getRestrictions(userId, restrictions) {
+        const response = await this.client.request("/restrictions", {
+            query: { userId, restriction: restrictions },
+        });
+        return sanitize(response ?? { items: [] });
+    }
     async getRouting(userId) {
         const [numbersResponse, usersResponse] = await Promise.all([
             userId
@@ -110,8 +425,8 @@ export class SipgateBackend {
             .map((user) => stringField(user, "id"))
             .filter((id) => Boolean(id));
         const users = await Promise.all(userIds.map(async (id) => {
-            const phonelinesResponse = await this.listPhonelines(id);
-            const phonelines = await Promise.all(asItems(phonelinesResponse).map(async (phoneline) => {
+            const phonelinesResult = await this.tryListPhonelines(id);
+            const phonelines = await Promise.all(asItems(phonelinesResult.value).map(async (phoneline) => {
                 const phonelineId = stringField(phoneline, "id");
                 if (!phonelineId)
                     return { ...phoneline, numbers: [], forwardings: [] };
@@ -130,10 +445,13 @@ export class SipgateBackend {
                     forwardings: asItems(forwardings),
                 };
             }));
-            return { userId: id, phonelines };
+            return { userId: id, phonelines, phonelinesAvailable: phonelinesResult.available };
         }));
+        const routedNumbers = users.flatMap(({ phonelines }) => phonelines.flatMap((phoneline) => phoneline.numbers));
         const numbers = userId
-            ? users.flatMap(({ phonelines }) => phonelines.flatMap((phoneline) => phoneline.numbers))
+            ? (routedNumbers.length > 0
+                ? routedNumbers
+                : asItems(await this.listUserNumbers(userId, { offset: 0, limit: 1000 })))
             : asItems(numbersResponse);
         const uniqueNumbers = [...new Map(numbers.map((number) => [
                 stringField(number, "id") ?? stringField(number, "number") ?? JSON.stringify(number),
@@ -141,6 +459,9 @@ export class SipgateBackend {
             ])).values()];
         return sanitize({ numbers: uniqueNumbers, users });
     }
+    async getHistoryEntry(entryId) {
+        return sanitize(await this.client.request(`/history/${encodeId(entryId)}`) ?? {});
+    }
     async getCallHistory(query) {
         const response = await this.client.request("/history", {
             query: {
@@ -152,6 +473,8 @@ export class SipgateBackend {
                 from: query.from,
                 to: query.to,
                 phonenumber: query.phoneNumber,
+                archived: query.archived,
+                starred: query.starred,
             },
         });
         const object = response && !Array.isArray(response) && typeof response === "object" ? response : {};
@@ -163,6 +486,43 @@ export class SipgateBackend {
             pagination: { offset: query.offset, limit: query.limit, totalCount, nextOffset },
         });
     }
+    async exportHistory(query) {
+        const content = await this.client.requestText("/history/export", {
+            query: {
+                connectionIds: query.connectionIds,
+                types: query.types,
+                directions: query.directions,
+                offset: query.offset,
+                limit: query.limit,
+                archived: query.archived,
+                starred: query.starred,
+                from: query.from,
+                to: query.to,
+            },
+            accept: "application/octet-stream",
+        });
+        return { content, contentType: "text/csv" };
+    }
+    async listCalls() {
+        const response = await this.client.request("/calls");
+        return sanitize(response ?? { data: [] });
+    }
+    async listNotifications(userId) {
+        const response = await this.client.request(`/${encodeId(userId)}/notifications`);
+        return sanitize(response ?? { call: [], fax: [], sms: [], voicemail: [] });
+    }
+    async listFaxlines(userId) {
+        const response = await this.client.request(`/${encodeId(userId)}/faxlines`);
+        return sanitize(response ?? { items: [] });
+    }
+    async listFaxlineNumbers(userId, faxlineId) {
+        const response = await this.client.request(`/${encodeId(userId)}/faxlines/${encodeId(faxlineId)}/numbers`);
+        return sanitize(response ?? { items: [] });
+    }
+    async getFaxlineCallerId(userId, faxlineId) {
+        const response = await this.client.request(`/${encodeId(userId)}/faxlines/${encodeId(faxlineId)}/callerid`);
+        return sanitize(response ?? {});
+    }
     async getSettings(userId) {
         const users = userId
             ? [await this.getUser(userId)]
@@ -174,11 +534,11 @@ export class SipgateBackend {
             const id = stringField(user, "id");
             if (!id)
                 return null;
-            const [devicesResponse, phonelinesResponse] = await Promise.all([
+            const [devicesResponse, phonelinesResult] = await Promise.all([
                 this.client.request(`/${encodeId(id)}/devices`),
-                this.client.request(`/${encodeId(id)}/phonelines`),
+                this.tryListPhonelines(id),
             ]);
-            const phonelines = await Promise.all(asItems(phonelinesResponse).map(async (line) => {
+            const phonelines = await Promise.all(asItems(phonelinesResult.value).map(async (line) => {
                 const lineId = stringField(line, "id");
                 if (!lineId)
                     return line;
@@ -192,10 +552,304 @@ export class SipgateBackend {
                     devices: asItems(devicesResponse),
                 },
                 phonelines,
+                phonelinesAvailable: phonelinesResult.available,
             };
         }));
         return sanitize({ users: settings.filter((item) => item !== null) });
     }
+    async getBalance() {
+        const response = await this.client.request("/balance");
+        return sanitize(response ?? {});
+    }
+    async listPortings() {
+        const response = await this.client.request("/portings");
+        return sanitize(response ?? { items: [] });
+    }
+    async getPorting(portingId) {
+        const response = await this.client.request(`/portings/${portingId}`);
+        return sanitize(response ?? {});
+    }
+    async getSipgateIoSettings() {
+        const { value, available, status } = await optional(this.client.request("/settings/sipgateio"));
+        return available
+            ? sanitize(value ?? {})
+            : unavailableFeature("the account-wide sipgate.io settings feature", status);
+    }
+    async listWebhookLogs() {
+        const { value, available, status } = await optional(this.client.request("/log/webhooks"));
+        if (!available) {
+            return unavailableFeature("the account-wide sipgate.io webhook log", status, true);
+        }
+        const logs = sanitize(value ?? { items: [] });
+        return stripUrlQueries(logs);
+    }
+    async createContact(input, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "create an account-wide contact");
+        const response = await this.client.request("/contacts", {
+            method: "POST",
+            body: this.contactBody(input),
+        });
+        return {
+            before: null,
+            after: sanitize({
+                created: true,
+                response: response ?? null,
+                note: "sipgate does not return the created contact ID, so no exact post-create read-back is possible.",
+            }),
+        };
+    }
+    async updateContact(contactId, input, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "change an account-wide contact");
+        const path = `/contacts/${encodeId(contactId)}`;
+        const before = await this.client.request(path);
+        await this.client.request(path, {
+            method: "PUT",
+            body: this.contactBody(input),
+        });
+        const after = await this.client.request(path);
+        return { before: sanitize(before ?? {}), after: sanitize(after ?? {}) };
+    }
+    async deleteContact(contactId, scopes, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "delete an account-wide contact");
+        const before = await this.client.request(`/contacts/${encodeId(contactId)}`);
+        const response = await this.client.request(`/contacts/${encodeId(contactId)}`, { method: "DELETE", query: { scope: scopes } });
+        return {
+            before: sanitize(before ?? {}),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate exposes no read-back for a deleted contact.",
+            }),
+        };
+    }
+    async deleteContacts(input, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "delete account-wide contacts");
+        const before = input.contactIds && input.contactIds.length > 0
+            ? await this.readContacts(input.contactIds)
+            : input.source === undefined
+                ? await this.listAllContacts(input.scope?.flatMap((scope) => scope === "PRIVATE,SHARED" ? ["PRIVATE", "SHARED"] : [scope]))
+                : null;
+        const response = await this.client.request("/contacts", {
+            method: "DELETE",
+            body: {
+                ...(input.contactIds === undefined ? {} : { contactIds: input.contactIds }),
+                ...(input.scope === undefined ? {} : { scope: input.scope }),
+                ...(input.source === undefined ? {} : { source: input.source }),
+            },
+        });
+        return {
+            before: sanitize(before),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: input.source !== undefined && !input.contactIds
+                    ? "sipgate's contact read endpoint has no source filter, so before is null for a source-selected delete; deleted contacts have no read-back."
+                    : "sipgate exposes no read-back for contacts removed by the bulk-delete endpoint.",
+            }),
+        };
+    }
+    async importContactsCsv(base64Content, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "import account-wide contacts");
+        const before = await this.listAllContacts();
+        await this.client.request("/contacts/import/csv", {
+            method: "POST",
+            body: { base64Content },
+        });
+        const after = await this.listAllContacts();
+        return { before, after };
+    }
+    async putContactsVcard(scope, data, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "replace account-wide contacts");
+        const contactIds = data
+            .map((entry) => entry.contactId)
+            .filter((contactId) => Boolean(contactId));
+        const beforeQuery = {
+            scopes: [scope],
+            ...(contactIds.length === 0 ? {} : { contactIds }),
+        };
+        const before = contactIds.length === 0 ? null : await this.getContactsVcard(beforeQuery);
+        const response = await this.client.request("/contacts/vcard", {
+            method: "PUT",
+            query: { scope },
+            body: { data: sanitize(data) },
+        });
+        const responseObject = response && !Array.isArray(response) && typeof response === "object"
+            ? response
+            : {};
+        const resultItems = Array.isArray(responseObject.result)
+            ? responseObject.result.filter((item) => Boolean(item) && !Array.isArray(item) && typeof item === "object")
+            : [];
+        const resultIds = resultItems
+            .map((entry) => stringField(entry, "contactId"))
+            .filter((contactId) => Boolean(contactId));
+        const readbackIds = [...new Set([...contactIds, ...resultIds])];
+        const after = await this.getContactsVcard({
+            scopes: [scope],
+            ...(readbackIds.length === 0 ? {} : { contactIds: readbackIds }),
+        });
+        return {
+            before,
+            after: sanitize({
+                contacts: after,
+                response: response ?? null,
+                ...(contactIds.length === data.length ? {} : {
+                    note: "New vCards had no before-state; sipgate's result IDs were used for post-write read-back when available.",
+                }),
+            }),
+        };
+    }
+    async addIncomingBlacklist(phoneNumber, isBlock, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "change the account-wide incoming blocklist");
+        const before = await this.listIncomingBlacklist();
+        await this.client.request("/blacklist/incoming", {
+            method: "POST",
+            body: { phoneNumber, ...(isBlock === undefined ? {} : { isBlock }) },
+        });
+        const after = await this.listIncomingBlacklist();
+        return { before, after };
+    }
+    async removeIncomingBlacklist(phoneNumber, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "change the account-wide incoming blocklist");
+        const entries = asItems(await this.listIncomingBlacklist());
+        const normalized = phoneNumber.startsWith("+") ? phoneNumber : `+${phoneNumber}`;
+        const before = entries.find((entry) => stringField(entry, "phoneNumber") === normalized) ?? null;
+        const response = await this.client.request(`/blacklist/incoming/${encodeId(phoneNumber)}`, { method: "DELETE" });
+        return {
+            before: sanitize(before),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate exposes no read-back for a deleted incoming blacklist entry.",
+            }),
+        };
+    }
+    async setCallRestriction(restriction, enabled) {
+        const { userId } = await this.getAuthenticatedUser();
+        const before = await this.getCallRestrictions([userId]);
+        await this.client.request(`/${encodeId(userId)}/callrestrictions/${encodeId(restriction)}`, {
+            method: "POST",
+            body: { ...(enabled === undefined ? {} : { enabled }) },
+        });
+        const after = await this.getCallRestrictions([userId]);
+        return { before, after };
+    }
+    setHistoryRead(entryId, value) {
+        return this.mutateHistoryWithReadback(entryId, `/history/${encodeId(entryId)}/read`, { ...(value === undefined ? {} : { value }) });
+    }
+    setHistoryNote(entryId, note) {
+        return this.mutateHistoryWithReadback(entryId, `/history/${encodeId(entryId)}/note`, { note });
+    }
+    setHistoryArchive(entryId, value) {
+        return this.mutateHistoryWithReadback(entryId, `/history/${encodeId(entryId)}/archive`, { ...(value === undefined ? {} : { value }) });
+    }
+    updateHistoryEntry(entryId, input) {
+        return this.mutateHistoryWithReadback(entryId, `/history/${encodeId(entryId)}`, {
+            ...(input.archived === undefined ? {} : { archived: input.archived }),
+            ...(input.note === undefined ? {} : { note: input.note }),
+            ...(input.read === undefined ? {} : { read: input.read }),
+            ...(input.starred === undefined ? {} : { starred: input.starred }),
+        });
+    }
+    async deleteHistoryEntry(entryId) {
+        const before = await this.client.request(`/history/${encodeId(entryId)}`);
+        const response = await this.client.request(`/history/${encodeId(entryId)}`, {
+            method: "DELETE",
+        });
+        return {
+            before: sanitize(before ?? {}),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "History deletion is permanent; sipgate exposes no deleted-entry read-back.",
+            }),
+        };
+    }
+    assertBulkHistoryLimit(count) {
+        if (count < 150)
+            return;
+        throw new SipgateApiError("sipgate accepts fewer than 150 history entries per bulk update.", 400);
+    }
+    async updateHistoryEntries(inputs) {
+        this.assertBulkHistoryLimit(inputs.length);
+        const before = await this.readHistoryEntries(inputs.map((input) => input.id));
+        await this.client.request("/history", {
+            method: "PUT",
+            body: inputs.map((input) => ({
+                id: input.id,
+                ...(input.archived === undefined ? {} : { archived: input.archived }),
+                ...(input.read === undefined ? {} : { read: input.read }),
+                ...(input.starred === undefined ? {} : { starred: input.starred }),
+            })),
+        });
+        const after = await this.readHistoryEntries(inputs.map((input) => input.id));
+        return { before: sanitize(before), after: sanitize(after) };
+    }
+    async deleteHistoryEntries(entryIds) {
+        if (entryIds !== undefined && entryIds.length === 0) {
+            // An empty list serializes to no query parameter at all, which sipgate
+            // reads as "delete the entire account history". Refuse it outright.
+            throw new SipgateApiError("Refusing to delete history with an empty entry list: omit the list deliberately to target the whole account.", 400);
+        }
+        const before = entryIds === undefined
+            ? await this.listAllHistoryEntries()
+            : await this.readHistoryEntries(entryIds);
+        const response = await this.client.request("/history", {
+            method: "DELETE",
+            query: { id: entryIds },
+        });
+        return {
+            before: sanitize(before),
+            after: sanitize({
+                deleted: true,
+                entryIds: entryIds ?? null,
+                response: response ?? null,
+                note: "History deletion is permanent; sipgate exposes no deleted-entry read-back.",
+            }),
+        };
+    }
+    async cancelPorting(portingId, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "cancel a number porting");
+        const before = await this.getPorting(portingId);
+        const response = await this.client.request(`/portings/${portingId}`, {
+            method: "DELETE",
+        });
+        return {
+            before,
+            after: sanitize({
+                cancelled: true,
+                response: response ?? null,
+                note: "Cancelling a number porting is irreversible through the sipgate v2 API.",
+            }),
+        };
+    }
+    async updateSipgateIoSettings(input, confirmAccountWide) {
+        assertConfirmed(confirmAccountWide, "change the account-wide sipgate.io settings");
+        const before = await optional(this.client.request("/settings/sipgateio"));
+        if (!before.available) {
+            return unavailableFeatureMutation("the account-wide sipgate.io settings feature", before.status);
+        }
+        await this.client.request("/settings/sipgateio", {
+            method: "PUT",
+            body: {
+                incomingUrl: input.incomingUrl,
+                outgoingUrl: input.outgoingUrl,
+                ...(input.log === undefined ? {} : { log: input.log }),
+                ...(input.pushApiVersion === undefined ? {} : { pushApiVersion: input.pushApiVersion }),
+                ...(input.whitelist === undefined ? {} : { whitelist: input.whitelist }),
+            },
+        });
+        const after = await optional(this.client.request("/settings/sipgateio"));
+        return {
+            before: sanitize(before.value ?? {}),
+            after: after.available
+                ? sanitize(after.value ?? {})
+                : {
+                    ...unavailableFeature("the account-wide sipgate.io settings feature", after.status),
+                    changed: true,
+                    note: "The change was accepted, but sipgate denied the settings read-back.",
+                },
+        };
+    }
     async setNumberRouting(numberId, endpointId) {
         const before = await this.findNumber(numberId);
         await this.client.request(`/numbers/${encodeId(numberId)}`, {
@@ -224,6 +878,209 @@ export class SipgateBackend {
         const after = await this.client.request(path);
         return { before: sanitize(before ?? { items: [] }), after: sanitize(after ?? { items: [] }) };
     }
+    async createPhoneline(userId) {
+        const { value, available } = await optional(this.client.request(`/${encodeId(userId)}/phonelines`, { method: "POST" }));
+        if (!available)
+            return phonelineMutationUnavailable();
+        return {
+            before: null,
+            after: sanitize({
+                phoneline: value ?? {},
+                created: true,
+                note: "No phoneline existed before this create operation; the returned phoneline is the initial state.",
+            }),
+        };
+    }
+    updatePhonelineAlias(userId, phonelineId, alias) {
+        const path = this.phonelinePath(userId, phonelineId);
+        return this.mutateOptionalPhonelineWithReadback(path, path, "PUT", { ...(alias === undefined ? {} : { alias }) });
+    }
+    async deletePhoneline(userId, phonelineId) {
+        const path = this.phonelinePath(userId, phonelineId);
+        const { value: before, available } = await optional(this.client.request(path));
+        if (!available)
+            return phonelineMutationUnavailable();
+        const response = await this.client.request(path, { method: "DELETE" });
+        return {
+            before: sanitize(before ?? {}),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate does not provide a deleted-phoneline read-back endpoint.",
+            }),
+        };
+    }
+    setPhonelineBlockAnonymous(userId, phonelineId, input) {
+        const path = this.phonelinePath(userId, phonelineId, "/blockanonymous");
+        return this.mutateOptionalPhonelineWithReadback(path, path, "PUT", {
+            ...(input.enabled === undefined ? {} : { enabled: input.enabled }),
+            ...(input.target === undefined ? {} : { target: input.target }),
+        });
+    }
+    attachDeviceToPhoneline(userId, phonelineId, deviceId) {
+        const path = this.phonelinePath(userId, phonelineId, "/devices");
+        return this.mutateOptionalPhonelineWithReadback(path, path, "POST", { deviceId }, true);
+    }
+    detachDeviceFromPhoneline(userId, phonelineId, deviceId) {
+        const readPath = this.phonelinePath(userId, phonelineId, "/devices");
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(deviceId)}`, "DELETE", undefined, true);
+    }
+    createParallelForwarding(userId, phonelineId, input) {
+        const path = this.phonelinePath(userId, phonelineId, "/parallelforwardings");
+        return this.mutateOptionalPhonelineWithReadback(path, path, "POST", this.parallelForwardingBody(input), true);
+    }
+    updateParallelForwarding(userId, phonelineId, parallelForwardingId, input) {
+        const readPath = this.phonelinePath(userId, phonelineId, "/parallelforwardings");
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(parallelForwardingId)}`, "PUT", this.parallelForwardingBody(input), true);
+    }
+    deleteParallelForwarding(userId, phonelineId, parallelForwardingId) {
+        const readPath = this.phonelinePath(userId, phonelineId, "/parallelforwardings");
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(parallelForwardingId)}`, "DELETE", undefined, true);
+    }
+    updateVoicemail(userId, phonelineId, voicemailId, input) {
+        const readPath = this.phonelinePath(userId, phonelineId, "/voicemails");
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(voicemailId)}`, "PUT", {
+            active: input.active,
+            transcription: input.transcription,
+            ...(input.timeout === undefined ? {} : { timeout: input.timeout }),
+        }, true);
+    }
+    createVoicemailGreeting(userId, phonelineId, voicemailId, input) {
+        const path = this.phonelinePath(userId, phonelineId, `/voicemails/${encodeId(voicemailId)}/greetings`);
+        return this.mutateOptionalPhonelineWithReadback(path, path, "POST", this.greetingBody(input), true);
+    }
+    updateVoicemailGreeting(userId, phonelineId, voicemailId, greetingId, active) {
+        const readPath = this.phonelinePath(userId, phonelineId, `/voicemails/${encodeId(voicemailId)}/greetings`);
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(greetingId)}`, "PUT", { ...(active === undefined ? {} : { active }) }, true);
+    }
+    deleteVoicemailGreeting(userId, phonelineId, voicemailId, greetingId) {
+        const readPath = this.phonelinePath(userId, phonelineId, `/voicemails/${encodeId(voicemailId)}/greetings`);
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(greetingId)}`, "DELETE", undefined, true);
+    }
+    setVoicemailTranscription(userId, phonelineId, voicemailId, active) {
+        const readPath = this.phonelinePath(userId, phonelineId, "/voicemails");
+        return this.mutateOptionalPhonelineWithReadback(readPath, `${readPath}/${encodeId(voicemailId)}/transcriptions`, "PUT", { ...(active === undefined ? {} : { active }) }, true);
+    }
+    async playVoicemail(input) {
+        const response = await this.client.request("/sessions/voicemail/play", {
+            method: "POST",
+            body: {
+                ...(input.dataId === undefined ? {} : { datadId: input.dataId }),
+                ...(input.deviceId === undefined ? {} : { deviceId: input.deviceId }),
+            },
+        });
+        return this.sessionMutationResult(response, "voicemail playback");
+    }
+    async recordVoicemailGreeting(input) {
+        const response = await this.client.request("/sessions/voicemail/recording", {
+            method: "POST",
+            body: {
+                ...(input.deviceId === undefined ? {} : { deviceId: input.deviceId }),
+                ...(input.endpoint === undefined ? {} : { endpoint: input.endpoint }),
+                ...(input.targetId === undefined ? {} : { targetId: input.targetId }),
+            },
+        });
+        return this.sessionMutationResult(response, "voicemail-greeting recording");
+    }
+    async createAutorecordingGreeting(input) {
+        const before = await optional(this.client.request("/autorecordings/greetings"));
+        if (!before.available)
+            return this.autorecordingUnavailableMutation();
+        await this.client.request("/autorecordings/greetings", {
+            method: "POST",
+            body: this.greetingBody(input),
+        });
+        const after = await optional(this.client.request("/autorecordings/greetings"));
+        return {
+            before: sanitize(before.value ?? {}),
+            after: after.available
+                ? sanitize(after.value ?? {})
+                : {
+                    autorecordingsAvailable: false,
+                    note: "The greeting was accepted, but automated call recording was unavailable during read-back.",
+                },
+        };
+    }
+    async deleteAutorecordingGreeting(greetingId) {
+        const before = await optional(this.client.request("/autorecordings/greetings"));
+        if (!before.available)
+            return this.autorecordingUnavailableMutation();
+        const current = before.value && !Array.isArray(before.value) && typeof before.value === "object"
+            ? before.value
+            : undefined;
+        const currentId = current === undefined ? undefined : stringField(current, "id");
+        if (currentId !== undefined && currentId !== greetingId) {
+            throw new SipgateApiError("The requested automated-recording greeting is not the one currently configured.", 404);
+        }
+        const response = await this.client.request(`/autorecordings/greetings/${encodeId(greetingId)}`, { method: "DELETE" });
+        return {
+            before: sanitize(before.value ?? {}),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate exposes no separate read-back for a deleted automated-recording greeting.",
+            }),
+        };
+    }
+    async setAutorecordingSettings(extension, active) {
+        const path = `/autorecordings/${encodeId(extension)}/settings`;
+        const before = await optional(this.client.request(path));
+        if (!before.available)
+            return this.autorecordingUnavailableMutation();
+        await this.client.request(path, {
+            method: "PUT",
+            body: { ...(active === undefined ? {} : { active }) },
+        });
+        const after = await optional(this.client.request(path));
+        return {
+            before: sanitize(before.value ?? {}),
+            after: after.available
+                ? sanitize(after.value ?? {})
+                : {
+                    autorecordingsAvailable: false,
+                    note: "The setting was accepted, but automated call recording was unavailable during read-back.",
+                },
+        };
+    }
+    async createFaxline(userId) {
+        const response = await this.client.request(`/${encodeId(userId)}/faxlines`, {
+            method: "POST",
+        });
+        return {
+            before: null,
+            after: sanitize({
+                faxline: response ?? {},
+                created: true,
+                note: "No faxline existed before this create operation; the returned faxline is the initial state.",
+            }),
+        };
+    }
+    updateFaxlineAlias(userId, faxlineId, alias) {
+        return this.mutateFaxlineWithReadback(userId, faxlineId, "", {
+            ...(alias === undefined ? {} : { alias }),
+        });
+    }
+    async deleteFaxline(userId, faxlineId) {
+        const before = await this.findFaxline(userId, faxlineId);
+        const response = await this.client.request(`/${encodeId(userId)}/faxlines/${encodeId(faxlineId)}`, { method: "DELETE" });
+        return {
+            before: sanitize(before),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate does not provide a deleted-faxline read-back endpoint.",
+            }),
+        };
+    }
+    setFaxlineCallerId(userId, faxlineId, value) {
+        const path = `/${encodeId(userId)}/faxlines/${encodeId(faxlineId)}/callerid`;
+        return this.mutateWithReadback(() => this.client.request(path), path, { ...(value === undefined ? {} : { value }) });
+    }
+    setFaxlineTagline(userId, faxlineId, value) {
+        return this.mutateFaxlineWithReadback(userId, faxlineId, "/tagline", {
+            ...(value === undefined ? {} : { value }),
+        });
+    }
     async setDnd(deviceId, enabled) {
         const path = `/devices/${encodeId(deviceId)}`;
         const before = await this.client.request(path);
@@ -231,6 +1088,137 @@ export class SipgateBackend {
         const after = await this.client.request(path);
         return { before: sanitize(before ?? {}), after: sanitize(after ?? {}) };
     }
+    async updateDevice(deviceId, settings) {
+        const path = `/devices/${encodeId(deviceId)}`;
+        return this.mutateWithReadback(() => this.client.request(path), path, {
+            ...(settings.dnd === undefined ? {} : { dnd: settings.dnd }),
+            ...(settings.emergencyAddressId === undefined
+                ? {}
+                : { emergencyAddressId: settings.emergencyAddressId }),
+        });
+    }
+    async deleteDevice(deviceId) {
+        const path = `/devices/${encodeId(deviceId)}`;
+        const before = await this.client.request(path);
+        const response = await this.client.request(path, { method: "DELETE" });
+        return {
+            before: sanitize(before ?? {}),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate does not provide a deleted-device read-back endpoint.",
+            }),
+        };
+    }
+    setDeviceAlias(deviceId, value) {
+        return this.mutateDeviceWithReadback(deviceId, `/devices/${encodeId(deviceId)}/alias`, {
+            ...(value === undefined ? {} : { value }),
+        });
+    }
+    async setDeviceCallerId(deviceId, value) {
+        const path = `/devices/${encodeId(deviceId)}/callerid`;
+        return this.mutateWithReadback(() => this.client.request(path), path, { ...(value === undefined ? {} : { value }) });
+    }
+    async setDeviceLocalPrefix(deviceId, input) {
+        const path = `/devices/${encodeId(deviceId)}/localprefix`;
+        return this.mutateWithReadback(() => this.client.request(path), path, {
+            ...(input.active === undefined ? {} : { active: input.active }),
+            ...(input.value === undefined ? {} : { value: input.value }),
+        });
+    }
+    async setDeviceTariffAnnouncement(deviceId, enabled) {
+        const path = `/devices/${encodeId(deviceId)}/tariffannouncement`;
+        return this.mutateWithReadback(() => this.client.request(path), path, { ...(enabled === undefined ? {} : { enabled }) });
+    }
+    async setDeviceSingleRowDisplay(deviceId, enabled) {
+        const path = `/devices/${encodeId(deviceId)}/singlerowdisplay`;
+        return this.mutateWithReadback(() => this.client.request(path), path, { ...(enabled === undefined ? {} : { enabled }) });
+    }
+    setExternalDeviceTargetNumber(deviceId, number) {
+        return this.mutateDeviceWithReadback(deviceId, `/devices/${encodeId(deviceId)}/external/targetnumber`, { ...(number === undefined ? {} : { number }) });
+    }
+    setExternalDeviceIncomingCallDisplay(deviceId, incomingCallDisplay) {
+        return this.mutateDeviceWithReadback(deviceId, `/devices/${encodeId(deviceId)}/external/incomingcalldisplay`, { incomingCallDisplay });
+    }
+    async changeDevicePassword(deviceId) {
+        const devicePath = `/devices/${encodeId(deviceId)}`;
+        const before = await this.client.request(devicePath);
+        const response = sanitize(await this.client.request(`${devicePath}/credentials/password`, { method: "POST" }) ?? {});
+        return {
+            before: sanitize(before ?? {}),
+            after: sanitize({
+                credentials: response,
+                passwordChanged: true,
+                note: "sipgate returns the new credential only once; credential values are intentionally redacted.",
+            }),
+        };
+    }
+    createRegisterDevice(userId, alias) {
+        return this.createDevice(`/${encodeId(userId)}/devices/register`, { ...(alias === undefined ? {} : { alias }) });
+    }
+    createMobileDevice(userId, alias) {
+        return this.createDevice(`/${encodeId(userId)}/devices/mobile`, { ...(alias === undefined ? {} : { alias }) });
+    }
+    createExternalDevice(userId, alias, number) {
+        return this.createDevice(`/${encodeId(userId)}/devices/external`, {
+            ...(alias === undefined ? {} : { alias }),
+            ...(number === undefined ? {} : { number }),
+        });
+    }
+    async createQuickDial(input) {
+        const response = await this.client.request("/numbers/quickdial", {
+            method: "POST",
+            body: {
+                userId: input.userId,
+                ...(input.number === undefined ? {} : { number: input.number }),
+            },
+        });
+        return {
+            before: null,
+            after: sanitize({
+                response: response ?? null,
+                requestAccepted: true,
+                note: "sipgate does not document a quick-dial creation read-back response; use list_user_numbers to inspect the result.",
+            }),
+        };
+    }
+    async updateQuickDial(quickDialId, input) {
+        const before = await this.findNumber(quickDialId);
+        await this.client.request(`/numbers/quickdial/${encodeId(quickDialId)}`, {
+            method: "PUT",
+            body: {
+                userId: input.userId,
+                ...(input.number === undefined ? {} : { number: input.number }),
+            },
+        });
+        const after = await this.findNumber(quickDialId);
+        return { before: sanitize(before), after: sanitize(after) };
+    }
+    async deleteQuickDial(numberId) {
+        const before = await this.findNumber(numberId);
+        const response = await this.client.request(`/numbers/quickdial/${encodeId(numberId)}`, { method: "DELETE" });
+        return {
+            before: sanitize(before),
+            after: sanitize({
+                deleted: true,
+                response: response ?? null,
+                note: "sipgate does not provide a deleted quick-dial read-back endpoint.",
+            }),
+        };
+    }
+    async updateAddress(addressId, input) {
+        const path = `/addresses/${addressId}`;
+        return this.mutateWithReadback(() => this.client.request(path), path, {
+            city: input.city,
+            countrycode: input.countrycode,
+            postcode: input.postcode,
+            ...(input.address1 === undefined ? {} : { address1: input.address1 }),
+            ...(input.address2 === undefined ? {} : { address2: input.address2 }),
+            ...(input.number === undefined ? {} : { number: input.number }),
+            ...(input.state === undefined ? {} : { state: input.state }),
+            ...(input.street === undefined ? {} : { street: input.street }),
+        });
+    }
     async sendSms(input) {
         const extensions = asItems(await this.client.request(`/${encodeId(input.userId)}/sms`));
         const extension = input.smsId
@@ -304,9 +1292,148 @@ export class SipgateBackend {
             },
         };
     }
+    createCallEmailNotification(input) {
+        return this.createNotification(input.userId, "/call/email", {
+            cause: input.cause,
+            direction: input.direction,
+            email: input.email,
+            endpointId: input.endpointId,
+        });
+    }
+    createCallSmsNotification(input) {
+        return this.createNotification(input.userId, "/call/sms", {
+            cause: input.cause,
+            direction: input.direction,
+            endpointId: input.endpointId,
+            number: input.number,
+        });
+    }
+    createFaxEmailNotification(input) {
+        return this.createNotification(input.userId, "/fax/email", {
+            direction: input.direction,
+            email: input.email,
+            faxlineId: input.faxlineId,
+        });
+    }
+    createFaxSmsNotification(input) {
+        return this.createNotification(input.userId, "/fax/sms", {
+            direction: input.direction,
+            faxlineId: input.faxlineId,
+            number: input.number,
+        });
+    }
+    createFaxReportNotification(input) {
+        return this.createNotification(input.userId, "/fax/report", { email: input.email, faxlineId: input.faxlineId });
+    }
+    createSmsEmailNotification(input) {
+        return this.createNotification(input.userId, "/sms/email", { email: input.email, endpointId: input.endpointId });
+    }
+    createVoicemailEmailNotification(input) {
+        return this.createNotification(input.userId, "/voicemail/email", { email: input.email, voicemailId: input.voicemailId });
+    }
+    createVoicemailSmsNotification(input) {
+        return this.createNotification(input.userId, "/voicemail/sms", { number: input.number, voicemailId: input.voicemailId });
+    }
+    async deleteNotification(userId, notificationId) {
+        const before = await this.listNotifications(userId);
+        await this.client.request(`/${encodeId(userId)}/notifications/${encodeId(notificationId)}`, { method: "DELETE" });
+        const after = await this.listNotifications(userId);
+        return { before, after };
+    }
+    async hangupCall(callId) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}`, "DELETE");
+    }
+    setCallHold(callId, value) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/hold`, "PUT", { value });
+    }
+    setCallMuted(callId, value) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/muted`, "PUT", { value });
+    }
+    setCallRecording(callId, value, announcement) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/recording`, "PUT", { value, ...(announcement === undefined ? {} : { announcement }) });
+    }
+    transferCall(callId, input) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/transfer`, "POST", {
+            attended: input.attended,
+            phoneNumber: input.phoneNumber,
+            ...(input.callerId === undefined ? {} : { callerId: input.callerId }),
+        });
+    }
+    sendCallDtmf(callId, sequence) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/dtmf`, "POST", { sequence });
+    }
+    startCallAnnouncement(callId, url) {
+        return this.mutateCallWithReadback(callId, `/calls/${encodeId(callId)}/announcements`, "POST", { url });
+    }
+    async sendFax(input) {
+        const response = await this.client.request("/sessions/fax", {
+            method: "POST",
+            body: {
+                base64Content: input.base64Content,
+                faxlineId: input.faxlineId,
+                filename: input.filename,
+                recipient: input.recipient,
+            },
+        });
+        return {
+            before: null,
+            after: sanitize({
+                session: response ?? null,
+                requestAccepted: true,
+                note: "sipgate does not expose a synchronous fax-session read-back; sending a fax may incur charges.",
+            }),
+        };
+    }
+    async resendFax(input) {
+        const response = await this.client.request("/sessions/fax/resend", {
+            method: "POST",
+            body: {
+                faxId: input.faxId,
+                ...(input.faxlineId === undefined ? {} : { faxlineId: input.faxlineId }),
+            },
+        });
+        return {
+            before: null,
+            after: sanitize({
+                response: response ?? null,
+                requestAccepted: true,
+                note: "sipgate does not document a fax-resend read-back response; resending a fax may incur charges.",
+            }),
+        };
+    }
+    async createNotification(userId, suffix, body) {
+        const before = await this.listNotifications(userId);
+        await this.client.request(`/${encodeId(userId)}/notifications${suffix}`, { method: "POST", body });
+        const after = await this.listNotifications(userId);
+        return { before, after };
+    }
+    async findActiveCall(callId) {
+        const response = await this.client.request("/calls");
+        return asCalls(response).find((call) => stringField(call, "callId") === callId);
+    }
+    async mutateCallWithReadback(callId, path, method, body) {
+        const before = await this.findActiveCall(callId);
+        if (!before)
+            throw new SipgateApiError("The requested active sipgate call was not found.", 404);
+        await this.client.request(path, {
+            method,
+            ...(body === undefined ? {} : { body }),
+        });
+        const after = await this.findActiveCall(callId);
+        return {
+            before: sanitize(before),
+            after: after
+                ? sanitize(after)
+                : {
+                    call: null,
+                    active: false,
+                    note: "The call no longer appears in sipgate's established-calls list after the operation.",
+                },
+        };
+    }
     async findNumber(numberId) {
-        const response = await this.client.request("/numbers", { query: { offset: 0, limit: 1000 } });
-        const number = asItems(response).find((item) => stringField(item, "id") === numberId);
+        const number = (await this.listAllAccountNumbers())
+            .find((item) => stringField(item, "id") === numberId);
         if (!number)
             throw new SipgateApiError("The requested sipgate phone number was not found.", 404);
         return number;
@@ -331,5 +1458,165 @@ export class SipgateBackend {
         });
         return asItems(response)[0] ?? null;
     }
+    async mutateWithReadback(read, path, body) {
+        const before = await read();
+        await this.client.request(path, { method: "PUT", body });
+        const after = await read();
+        return { before: sanitize(before ?? {}), after: sanitize(after ?? {}) };
+    }
+    mutateDeviceWithReadback(deviceId, path, body) {
+        return this.mutateWithReadback(() => this.client.request(`/devices/${encodeId(deviceId)}`), path, body);
+    }
+    async mutateOptionalPhonelineWithReadback(readPath, writePath, method, body, list = false) {
+        const before = await optional(this.client.request(readPath));
+        if (!before.available)
+            return phonelineMutationUnavailable(before.status);
+        await this.client.request(writePath, {
+            method,
+            ...(body === undefined ? {} : { body }),
+        });
+        const after = await optional(this.client.request(readPath));
+        return {
+            before: sanitize(before.value ?? (list ? { items: [] } : {})),
+            after: after.available
+                ? sanitize(after.value ?? (list ? { items: [] } : {}))
+                : {
+                    ...phonelineUnavailable(list, after.status),
+                    changed: true,
+                    note: "The change was applied, but sipgate denied the read-back so the new state could not be confirmed.",
+                },
+        };
+    }
+    parallelForwardingBody(input) {
+        return {
+            ...(input.active === undefined ? {} : { active: input.active }),
+            ...(input.alias === undefined ? {} : { alias: input.alias }),
+            ...(input.destination === undefined ? {} : { destination: input.destination }),
+        };
+    }
+    greetingBody(input) {
+        return {
+            ...(input.base64Content === undefined ? {} : { base64Content: input.base64Content }),
+            ...(input.filename === undefined ? {} : { filename: input.filename }),
+        };
+    }
+    sessionMutationResult(response, action) {
+        return {
+            before: null,
+            after: sanitize({
+                session: response ?? null,
+                requestAccepted: true,
+                note: `sipgate exposes no synchronous ${action} read-back. The call may incur charges; the caller is responsible for consent where recording law requires it.`,
+            }),
+        };
+    }
+    autorecordingUnavailableMutation() {
+        return {
+            before: null,
+            after: {
+                changed: false,
+                autorecordingsAvailable: false,
+                note: "Automated call recording is not activated for this sipgate account; no change was attempted.",
+            },
+        };
+    }
+    async findFaxline(userId, faxlineId) {
+        const response = await this.listFaxlines(userId);
+        const faxline = asItems(response).find((item) => stringField(item, "id") === faxlineId);
+        if (!faxline)
+            throw new SipgateApiError("The requested sipgate faxline was not found.", 404);
+        return faxline;
+    }
+    async mutateFaxlineWithReadback(userId, faxlineId, suffix, body) {
+        const before = await this.findFaxline(userId, faxlineId);
+        await this.client.request(`/${encodeId(userId)}/faxlines/${encodeId(faxlineId)}${suffix}`, { method: "PUT", body });
+        const after = await this.findFaxline(userId, faxlineId);
+        return { before: sanitize(before), after: sanitize(after) };
+    }
+    contactBody(input) {
+        return {
+            ...(input.addresses === undefined ? {} : { addresses: sanitize(input.addresses) }),
+            ...(input.emails === undefined ? {} : { emails: sanitize(input.emails) }),
+            ...(input.family === undefined ? {} : { family: input.family }),
+            ...(input.given === undefined ? {} : { given: input.given }),
+            ...("id" in input && typeof input.id === "string" ? { id: input.id } : {}),
+            ...(input.name === undefined ? {} : { name: input.name }),
+            ...(input.note === undefined ? {} : { note: input.note }),
+            ...(input.numbers === undefined ? {} : { numbers: sanitize(input.numbers) }),
+            ...(input.organization === undefined ? {} : { organization: input.organization }),
+            ...(input.picture === undefined ? {} : { picture: input.picture }),
+            ...(input.scope === undefined ? {} : { scope: input.scope }),
+            ...(input.websites === undefined ? {} : { websites: sanitize(input.websites) }),
+        };
+    }
+    async readContacts(contactIds) {
+        const contacts = [];
+        for (const contactId of contactIds)
+            contacts.push(await this.getContact(contactId));
+        return contacts;
+    }
+    async listAllContacts(scopes) {
+        const all = [];
+        const limit = 5000;
+        let lastId;
+        for (;;) {
+            const response = await this.listContacts({
+                limit,
+                ...(lastId === undefined ? {} : { lastId }),
+                ...(scopes === undefined ? {} : { scopes }),
+            });
+            const page = asItems(response);
+            all.push(...page);
+            if (page.length < limit)
+                break;
+            const nextLastId = stringField(page[page.length - 1] ?? {}, "id");
+            if (!nextLastId || nextLastId === lastId)
+                break;
+            lastId = nextLastId;
+        }
+        return sanitize({ items: all, totalCount: all.length });
+    }
+    async readHistoryEntries(entryIds) {
+        const entries = [];
+        for (const entryId of entryIds)
+            entries.push(await this.getHistoryEntry(entryId));
+        return entries;
+    }
+    async listAllHistoryEntries() {
+        const all = [];
+        const pageSize = 1000;
+        for (const archived of [false, true]) {
+            for (let offset = 0;; offset += pageSize) {
+                const response = await this.getCallHistory({
+                    archived,
+                    offset,
+                    limit: pageSize,
+                    types: ["CALL", "VOICEMAIL", "SMS", "FAX"],
+                });
+                const page = asItems(response);
+                all.push(...page);
+                if (page.length < pageSize)
+                    break;
+            }
+        }
+        return all;
+    }
+    async mutateHistoryWithReadback(entryId, path, body) {
+        const before = await this.client.request(`/history/${encodeId(entryId)}`);
+        await this.client.request(path, { method: "PUT", body });
+        const after = await this.client.request(`/history/${encodeId(entryId)}`);
+        return { before: sanitize(before ?? {}), after: sanitize(after ?? {}) };
+    }
+    async createDevice(path, body) {
+        const response = await this.client.request(path, { method: "POST", body });
+        return {
+            before: null,
+            after: sanitize({
+                device: response ?? {},
+                created: true,
+                note: "No device existed before this create operation; the returned device is the initial state.",
+            }),
+        };
+    }
 }
 //# sourceMappingURL=sipgate-backend.js.map