doover-js 0.5.4 → 0.6.0

package/dist/apis/channels-api.js

@@ -1,23 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelsApi = void 0;
+const _args_1 = require("./_args");
 class ChannelsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    listChannels(agentId, options) {
+    listChannels(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._listChannels(agentId, options);
+    }
+    _listChannels(agentId, options) {
         return this.rest.get(`/agents/${agentId}/channels`, options);
     }
-    getChannel(agentId, channelName, options) {
+    getChannel(...args) {
+        const { agentId, channelName, options } = (0, _args_1.resolveChannelArgs)(args);
+        return this._getChannel(agentId, channelName, options);
+    }
+    _getChannel(agentId, channelName, options) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}`, options);
     }
-    createChannel(agentId, channelName, body) {
+    createChannel(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._createChannel(agentId, channelName, body);
+        }
+        const id = args[0];
+        const body = args[1];
+        return this._createChannel(id.agentId, id.channelName, body);
+    }
+    _createChannel(agentId, channelName, body) {
         return this.rest.post(`/agents/${agentId}/channels/${channelName}`, body);
     }
-    putChannel(agentId, channelName, body) {
+    putChannel(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._putChannel(agentId, channelName, body);
+        }
+        const id = args[0];
+        const body = args[1];
+        return this._putChannel(id.agentId, id.channelName, body);
+    }
+    _putChannel(agentId, channelName, body) {
         return this.rest.put(`/agents/${agentId}/channels/${channelName}`, body);
     }
-    listDataSeries(agentId, params) {
+    archiveChannel(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._archiveChannel(agentId, channelName);
+    }
+    _archiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/archive`, {});
+    }
+    unarchiveChannel(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._unarchiveChannel(agentId, channelName);
+    }
+    _unarchiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/unarchive`, {});
+    }
+    listDataSeries(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._listDataSeries(agentId, options);
+    }
+    _listDataSeries(agentId, params) {
         return this.rest.get(`/agents/${agentId}/data_series`, params);
     }
 }

package/dist/apis/connections-api.d.ts

@@ -16,14 +16,30 @@ export declare class ConnectionsApi {
     private readonly rest;
     constructor(rest: RestClient);
     getAgentConnections(agentId: string): Promise<ConnectionDetails[]>;
+    getAgentConnections(identifier: {
+        agentId: string;
+    }): Promise<ConnectionDetails[]>;
+    private _getAgentConnections;
     getAgentConnectionHistory(agentId: string, params: ConnectionHistoryParams): Promise<ConnectionDetails[]>;
+    getAgentConnectionHistory(identifier: {
+        agentId: string;
+    }, params: ConnectionHistoryParams): Promise<ConnectionDetails[]>;
+    private _getAgentConnectionHistory;
     getAgentSubscriptionHistory(agentId: string, params: SubscriptionHistoryParams): Promise<ConnectionSubscriptionLog[]>;
+    getAgentSubscriptionHistory(identifier: {
+        agentId: string;
+    }, params: SubscriptionHistoryParams): Promise<ConnectionSubscriptionLog[]>;
+    private _getAgentSubscriptionHistory;
     getConnection(connectionId: string): Promise<ConnectionDetails>;
     getChannelSubscriptions(agentId: string, channelName: string): Promise<ConnectionSubscription[]>;
-    /**
-     * Ask the server to push the latest state of all channels this agent
-     * owns to every active WSS connection. Used to recover from missed updates
-     * after a gap in connectivity.
-     */
+    getChannelSubscriptions(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<ConnectionSubscription[]>;
+    private _getChannelSubscriptions;
     syncConnection(agentId: string): Promise<unknown>;
+    syncConnection(identifier: {
+        agentId: string;
+    }): Promise<unknown>;
+    private _syncConnection;
 }

package/dist/apis/connections-api.js

@@ -1,31 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionsApi = void 0;
+const _args_1 = require("./_args");
 class ConnectionsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    getAgentConnections(agentId) {
+    getAgentConnections(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentConnections(agentId);
+    }
+    _getAgentConnections(agentId) {
         return this.rest.get(`/agents/${agentId}/wss_connections`);
     }
-    getAgentConnectionHistory(agentId, params) {
+    getAgentConnectionHistory(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentConnectionHistory(agentId, options);
+    }
+    _getAgentConnectionHistory(agentId, params) {
         return this.rest.get(`/agents/${agentId}/wss_connections/history`, params);
     }
-    getAgentSubscriptionHistory(agentId, params) {
+    getAgentSubscriptionHistory(...args) {
+        const { agentId, options } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentSubscriptionHistory(agentId, options);
+    }
+    _getAgentSubscriptionHistory(agentId, params) {
         return this.rest.get(`/agents/${agentId}/wss_connections/subscriptions/history`, params);
     }
     getConnection(connectionId) {
         return this.rest.get(`/connections/${connectionId}`);
     }
-    getChannelSubscriptions(agentId, channelName) {
+    getChannelSubscriptions(...args) {
+        const { agentId, channelName } = (0, _args_1.resolveChannelArgs)(args);
+        return this._getChannelSubscriptions(agentId, channelName);
+    }
+    _getChannelSubscriptions(agentId, channelName) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/subscriptions`);
     }
-    /**
-     * Ask the server to push the latest state of all channels this agent
-     * owns to every active WSS connection. Used to recover from missed updates
-     * after a gap in connectivity.
-     */
-    syncConnection(agentId) {
+    syncConnection(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._syncConnection(agentId);
+    }
+    _syncConnection(agentId) {
         return this.rest.post(`/agents/${agentId}/connection_sync`, {});
     }
 }

package/dist/apis/messages-api.d.ts

@@ -5,6 +5,12 @@ export interface ListMessagesParams {
     after?: string;
     limit?: number;
     field_name?: string[];
+    /**
+     * Result order. `"desc"` (default) returns the server's native newest-first
+     * order; `"asc"` reverses the array client-side so the oldest message is at
+     * index 0.
+     */
+    order?: "asc" | "desc";
 }
 export interface MessageMutationParams {
     suppress_response?: boolean;
@@ -14,20 +20,59 @@ export type MessageBody = CreateMessageRequest | UpdateMessageRequest | FormData
 export declare class MessagesApi {
     private readonly rest;
     constructor(rest: RestClient);
-    listMessages(agentId: string, channelName: string, params?: ListMessagesParams): Promise<(Omit<MessageStructure<import("..").JSONValue>, "timestamp"> & {
-        timestamp: number;
-    })[]>;
-    postMessage(agentId: string, channelName: string, body: MessageBody): Promise<Omit<MessageStructure<import("..").JSONValue>, "timestamp"> & {
-        timestamp: number;
-    }>;
+    listMessages(agentId: string, channelName: string, params?: ListMessagesParams): Promise<MessageStructure[]>;
+    listMessages(identifier: {
+        agentId: string;
+        channelName: string;
+    }, params?: ListMessagesParams): Promise<MessageStructure[]>;
+    private _listMessages;
+    postMessage(agentId: string, channelName: string, body: MessageBody): Promise<MessageStructure>;
+    postMessage(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: MessageBody): Promise<MessageStructure>;
+    private _postMessage;
     getTimeseries(agentId: string, channelName: string, params: ListMessagesParams): Promise<DataSeries>;
-    getMessage(agentId: string, channelName: string, messageId: string): Promise<Omit<MessageStructure<import("..").JSONValue>, "timestamp"> & {
-        timestamp: number;
-    }>;
+    getTimeseries(identifier: {
+        agentId: string;
+        channelName: string;
+    }, params: ListMessagesParams): Promise<DataSeries>;
+    private _getTimeseries;
+    getMessage(agentId: string, channelName: string, messageId: string): Promise<MessageStructure>;
+    getMessage(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string): Promise<MessageStructure>;
+    private _getMessage;
     putMessage(agentId: string, channelName: string, messageId: string, body: MessageBody, params?: MessageMutationParams): Promise<unknown>;
+    putMessage(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string, body: MessageBody, params?: MessageMutationParams): Promise<unknown>;
+    private _putMessage;
     patchMessage(agentId: string, channelName: string, messageId: string, body: MessageBody, params?: MessageMutationParams): Promise<unknown>;
+    patchMessage(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string, body: MessageBody, params?: MessageMutationParams): Promise<unknown>;
+    private _patchMessage;
     deleteMessage(agentId: string, channelName: string, messageId: string): Promise<unknown>;
+    deleteMessage(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string): Promise<unknown>;
+    private _deleteMessage;
     getMessageAttachment(agentId: string, channelName: string, messageId: string, attachmentId: string): Promise<Blob>;
+    getMessageAttachment(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string, attachmentId: string): Promise<Blob>;
+    private _getMessageAttachment;
     getInvocationLogs<TLog = unknown>(agentId: string, channelName: string, messageId: string): Promise<TLog[]>;
+    getInvocationLogs<TLog = unknown>(identifier: {
+        agentId: string;
+        channelName: string;
+    }, messageId: string): Promise<TLog[]>;
+    private _getInvocationLogs;
     createMultipartPayload(jsonPayload: Record<string, unknown>, attachments: Array<Blob | File>): FormData;
 }

package/dist/apis/messages-api.js

@@ -2,38 +2,120 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessagesApi = void 0;
 const snowflake_1 = require("../utils/snowflake");
+const _args_1 = require("./_args");
+function resolveListMessagesParams(params) {
+    const order = params?.order ?? "desc";
+    const query = {
+        before: params?.before ?? (0, snowflake_1.generateSnowflakeIdAtTime)(new Date()),
+        limit: params?.limit ?? 10,
+    };
+    if (params?.after !== undefined)
+        query.after = params.after;
+    if (params?.field_name !== undefined)
+        query.field_name = params.field_name;
+    return { query, order };
+}
 class MessagesApi {
     constructor(rest) {
         this.rest = rest;
     }
-    async listMessages(agentId, channelName, params) {
-        const response = await this.rest.get(`/agents/${agentId}/channels/${channelName}/messages`, params);
-        return response.map(snowflake_1.addTimestampToMessage);
+    async listMessages(...args) {
+        const { agentId, channelName, options } = (0, _args_1.resolveChannelArgs)(args);
+        return this._listMessages(agentId, channelName, options);
+    }
+    async _listMessages(agentId, channelName, params) {
+        const { query, order } = resolveListMessagesParams(params);
+        const response = await this.rest.get(`/agents/${agentId}/channels/${channelName}/messages`, query);
+        const stamped = response.map(snowflake_1.addTimestampToMessage);
+        return order === "asc" ? [...stamped].reverse() : stamped;
+    }
+    async postMessage(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._postMessage(agentId, channelName, body);
+        }
+        const id = args[0];
+        const body = args[1];
+        return this._postMessage(id.agentId, id.channelName, body);
     }
-    async postMessage(agentId, channelName, body) {
+    async _postMessage(agentId, channelName, body) {
         const response = await this.rest.post(`/agents/${agentId}/channels/${channelName}/messages`, body);
         return (0, snowflake_1.addTimestampToMessage)(response);
     }
-    getTimeseries(agentId, channelName, params) {
-        return this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/timeseries`, params);
+    getTimeseries(...args) {
+        const { agentId, channelName, options } = (0, _args_1.resolveChannelArgs)(args);
+        return this._getTimeseries(agentId, channelName, options);
+    }
+    _getTimeseries(agentId, channelName, params) {
+        const { order: _order, ...rest } = params;
+        return this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/timeseries`, rest);
+    }
+    async getMessage(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId] = args;
+            return this._getMessage(agentId, channelName, messageId);
+        }
+        const id = args[0];
+        const messageId = args[1];
+        return this._getMessage(id.agentId, id.channelName, messageId);
     }
-    async getMessage(agentId, channelName, messageId) {
+    async _getMessage(agentId, channelName, messageId) {
         const response = await this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/${messageId}`);
         return (0, snowflake_1.addTimestampToMessage)(response);
     }
-    putMessage(agentId, channelName, messageId, body, params) {
+    putMessage(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId, body, params] = args;
+            return this._putMessage(agentId, channelName, messageId, body, params);
+        }
+        const id = args[0];
+        return this._putMessage(id.agentId, id.channelName, args[1], args[2], args[3]);
+    }
+    _putMessage(agentId, channelName, messageId, body, params) {
         return this.rest.put(`/agents/${agentId}/channels/${channelName}/messages/${messageId}`, body, params);
     }
-    patchMessage(agentId, channelName, messageId, body, params) {
+    patchMessage(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId, body, params] = args;
+            return this._patchMessage(agentId, channelName, messageId, body, params);
+        }
+        const id = args[0];
+        return this._patchMessage(id.agentId, id.channelName, args[1], args[2], args[3]);
+    }
+    _patchMessage(agentId, channelName, messageId, body, params) {
         return this.rest.patch(`/agents/${agentId}/channels/${channelName}/messages/${messageId}`, body, params);
     }
-    deleteMessage(agentId, channelName, messageId) {
+    deleteMessage(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId] = args;
+            return this._deleteMessage(agentId, channelName, messageId);
+        }
+        const id = args[0];
+        return this._deleteMessage(id.agentId, id.channelName, args[1]);
+    }
+    _deleteMessage(agentId, channelName, messageId) {
         return this.rest.delete(`/agents/${agentId}/channels/${channelName}/messages/${messageId}`);
     }
-    getMessageAttachment(agentId, channelName, messageId, attachmentId) {
+    getMessageAttachment(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId, attachmentId] = args;
+            return this._getMessageAttachment(agentId, channelName, messageId, attachmentId);
+        }
+        const id = args[0];
+        return this._getMessageAttachment(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _getMessageAttachment(agentId, channelName, messageId, attachmentId) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/${messageId}/attachments/${attachmentId}`);
     }
-    getInvocationLogs(agentId, channelName, messageId) {
+    getInvocationLogs(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, messageId] = args;
+            return this._getInvocationLogs(agentId, channelName, messageId);
+        }
+        const id = args[0];
+        return this._getInvocationLogs(id.agentId, id.channelName, args[1]);
+    }
+    _getInvocationLogs(agentId, channelName, messageId) {
         return this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/${messageId}/logs`);
     }
     createMultipartPayload(jsonPayload, attachments) {

package/dist/apis/notifications-api.d.ts

@@ -4,18 +4,70 @@ export declare class NotificationsApi {
     private readonly rest;
     constructor(rest: RestClient);
     getAgentNotifications(agentId: string): Promise<NotificationDataResponse>;
+    getAgentNotifications(identifier: {
+        agentId: string;
+    }): Promise<NotificationDataResponse>;
+    private _getAgentNotifications;
     getAgentNotificationEndpoints(agentId: string, name?: string): Promise<NotificationEndpointsResponse>;
+    getAgentNotificationEndpoints(identifier: {
+        agentId: string;
+    }, name?: string): Promise<NotificationEndpointsResponse>;
+    private _getAgentNotificationEndpoints;
     createNotificationEndpoint(agentId: string, body: CreateEndpointRequest): Promise<NotificationEndpoint>;
+    createNotificationEndpoint(identifier: {
+        agentId: string;
+    }, body: CreateEndpointRequest): Promise<NotificationEndpoint>;
+    private _createNotificationEndpoint;
     updateNotificationEndpoint(agentId: string, endpointId: string, body: UpdateEndpointRequest): Promise<NotificationEndpoint>;
+    updateNotificationEndpoint(identifier: {
+        agentId: string;
+    }, endpointId: string, body: UpdateEndpointRequest): Promise<NotificationEndpoint>;
+    private _updateNotificationEndpoint;
     deleteNotificationEndpoint(agentId: string, endpointId: string): Promise<unknown>;
+    deleteNotificationEndpoint(identifier: {
+        agentId: string;
+    }, endpointId: string): Promise<unknown>;
+    private _deleteNotificationEndpoint;
     testNotificationEndpoint(agentId: string, endpointId: string): Promise<unknown>;
+    testNotificationEndpoint(identifier: {
+        agentId: string;
+    }, endpointId: string): Promise<unknown>;
+    private _testNotificationEndpoint;
     getAgentNotificationSubscriptions(agentId: string, subscribed_to?: string): Promise<NotificationSubscriptionsResponse>;
+    getAgentNotificationSubscriptions(identifier: {
+        agentId: string;
+    }, subscribed_to?: string): Promise<NotificationSubscriptionsResponse>;
+    private _getAgentNotificationSubscriptions;
     createNotificationSubscription(agentId: string, body: CreateNotificationSubscriptionRequest): Promise<NotificationSubscriptionCreateResponse>;
+    createNotificationSubscription(identifier: {
+        agentId: string;
+    }, body: CreateNotificationSubscriptionRequest): Promise<NotificationSubscriptionCreateResponse>;
+    private _createNotificationSubscription;
     getAgentDefaultNotificationSubscriptions(agentId: string, subscribed_to?: string): Promise<NotificationSubscriptionsResponse>;
+    getAgentDefaultNotificationSubscriptions(identifier: {
+        agentId: string;
+    }, subscribed_to?: string): Promise<NotificationSubscriptionsResponse>;
+    private _getAgentDefaultNotificationSubscriptions;
     deleteDefaultNotificationSubscription(agentId: string, subscribedTo: string): Promise<unknown>;
+    deleteDefaultNotificationSubscription(identifier: {
+        agentId: string;
+    }, subscribedTo: string): Promise<unknown>;
+    private _deleteDefaultNotificationSubscription;
     updateNotificationSubscription(agentId: string, subscriptionId: string, body: UpdateNotificationSubscriptionRequest): Promise<unknown>;
+    updateNotificationSubscription(identifier: {
+        agentId: string;
+    }, subscriptionId: string, body: UpdateNotificationSubscriptionRequest): Promise<unknown>;
+    private _updateNotificationSubscription;
     deleteNotificationSubscription(agentId: string, subscriptionId: string): Promise<unknown>;
+    deleteNotificationSubscription(identifier: {
+        agentId: string;
+    }, subscriptionId: string): Promise<unknown>;
+    private _deleteNotificationSubscription;
     getAgentNotificationSubscribers(agentId: string): Promise<NotificationSubscribersResponse>;
+    getAgentNotificationSubscribers(identifier: {
+        agentId: string;
+    }): Promise<NotificationSubscribersResponse>;
+    private _getAgentNotificationSubscribers;
     updateMeWebPushEndpoint(body: UpdateMeWebPushEndpointRequest): Promise<unknown>;
     getWebPushPublicKey(): Promise<{
         key: string;

package/dist/apis/notifications-api.js

@@ -1,47 +1,133 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationsApi = void 0;
+const _args_1 = require("./_args");
 class NotificationsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    getAgentNotifications(agentId) {
+    getAgentNotifications(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentNotifications(agentId);
+    }
+    _getAgentNotifications(agentId) {
         return this.rest.get(`/agents/${agentId}/notifications`);
     }
-    getAgentNotificationEndpoints(agentId, name) {
+    getAgentNotificationEndpoints(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentNotificationEndpoints(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentNotificationEndpoints(id.agentId, args[1]);
+    }
+    _getAgentNotificationEndpoints(agentId, name) {
         return this.rest.get(`/agents/${agentId}/notifications/endpoints`, { name });
     }
-    createNotificationEndpoint(agentId, body) {
+    createNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._createNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._createNotificationEndpoint(id.agentId, args[1]);
+    }
+    _createNotificationEndpoint(agentId, body) {
         return this.rest.post(`/agents/${agentId}/notifications/endpoints`, body);
     }
-    updateNotificationEndpoint(agentId, endpointId, body) {
+    updateNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateNotificationEndpoint(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateNotificationEndpoint(id.agentId, args[1], args[2]);
+    }
+    _updateNotificationEndpoint(agentId, endpointId, body) {
         return this.rest.patch(`/agents/${agentId}/notifications/endpoints/${endpointId}`, body);
     }
-    deleteNotificationEndpoint(agentId, endpointId) {
+    deleteNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteNotificationEndpoint(id.agentId, args[1]);
+    }
+    _deleteNotificationEndpoint(agentId, endpointId) {
         return this.rest.delete(`/agents/${agentId}/notifications/endpoints/${endpointId}`);
     }
-    testNotificationEndpoint(agentId, endpointId) {
+    testNotificationEndpoint(...args) {
+        if (typeof args[0] === "string") {
+            return this._testNotificationEndpoint(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._testNotificationEndpoint(id.agentId, args[1]);
+    }
+    _testNotificationEndpoint(agentId, endpointId) {
         return this.rest.post(`/agents/${agentId}/notifications/endpoints/${endpointId}/test`, {});
     }
-    getAgentNotificationSubscriptions(agentId, subscribed_to) {
+    getAgentNotificationSubscriptions(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentNotificationSubscriptions(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentNotificationSubscriptions(id.agentId, args[1]);
+    }
+    _getAgentNotificationSubscriptions(agentId, subscribed_to) {
         return this.rest.get(`/agents/${agentId}/notifications/subscriptions`, { subscribed_to });
     }
-    createNotificationSubscription(agentId, body) {
+    createNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._createNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._createNotificationSubscription(id.agentId, args[1]);
+    }
+    _createNotificationSubscription(agentId, body) {
         return this.rest.post(`/agents/${agentId}/notifications/subscriptions`, body);
     }
-    getAgentDefaultNotificationSubscriptions(agentId, subscribed_to) {
+    getAgentDefaultNotificationSubscriptions(...args) {
+        if (typeof args[0] === "string") {
+            return this._getAgentDefaultNotificationSubscriptions(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._getAgentDefaultNotificationSubscriptions(id.agentId, args[1]);
+    }
+    _getAgentDefaultNotificationSubscriptions(agentId, subscribed_to) {
         return this.rest.get(`/agents/${agentId}/notifications/subscriptions/default`, { subscribed_to });
     }
-    deleteDefaultNotificationSubscription(agentId, subscribedTo) {
+    deleteDefaultNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteDefaultNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteDefaultNotificationSubscription(id.agentId, args[1]);
+    }
+    _deleteDefaultNotificationSubscription(agentId, subscribedTo) {
         return this.rest.delete(`/agents/${agentId}/notifications/subscriptions/default/${subscribedTo}`);
     }
-    updateNotificationSubscription(agentId, subscriptionId, body) {
+    updateNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._updateNotificationSubscription(args[0], args[1], args[2]);
+        }
+        const id = args[0];
+        return this._updateNotificationSubscription(id.agentId, args[1], args[2]);
+    }
+    _updateNotificationSubscription(agentId, subscriptionId, body) {
         return this.rest.patch(`/agents/${agentId}/notifications/subscriptions/${subscriptionId}`, body);
     }
-    deleteNotificationSubscription(agentId, subscriptionId) {
+    deleteNotificationSubscription(...args) {
+        if (typeof args[0] === "string") {
+            return this._deleteNotificationSubscription(args[0], args[1]);
+        }
+        const id = args[0];
+        return this._deleteNotificationSubscription(id.agentId, args[1]);
+    }
+    _deleteNotificationSubscription(agentId, subscriptionId) {
         return this.rest.delete(`/agents/${agentId}/notifications/subscriptions/${subscriptionId}`);
     }
-    getAgentNotificationSubscribers(agentId) {
+    getAgentNotificationSubscribers(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentNotificationSubscribers(agentId);
+    }
+    _getAgentNotificationSubscribers(agentId) {
         return this.rest.get(`/agents/${agentId}/notifications/subscribers`);
     }
     updateMeWebPushEndpoint(body) {

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

@@ -4,6 +4,14 @@ export declare class PermissionsApi {
     private readonly rest;
     constructor(rest: RestClient);
     getAgentPermission(agentId: string): Promise<AgentPermission>;
+    getAgentPermission(identifier: {
+        agentId: string;
+    }): Promise<AgentPermission>;
+    private _getAgentPermission;
     getAgentPermissionDebug(agentId: string): Promise<PermissionDebugResponse>;
+    getAgentPermissionDebug(identifier: {
+        agentId: string;
+    }): Promise<PermissionDebugResponse>;
+    private _getAgentPermissionDebug;
     syncPermissions(body: SyncPermissionRequest): Promise<SuccessListResponse<string>>;
 }

package/dist/apis/permissions-api.js

@@ -1,14 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PermissionsApi = void 0;
+const _args_1 = require("./_args");
 class PermissionsApi {
     constructor(rest) {
         this.rest = rest;
     }
-    getAgentPermission(agentId) {
+    getAgentPermission(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentPermission(agentId);
+    }
+    _getAgentPermission(agentId) {
         return this.rest.get(`/agents/${agentId}/permissions`);
     }
-    getAgentPermissionDebug(agentId) {
+    getAgentPermissionDebug(...args) {
+        const { agentId } = (0, _args_1.resolveAgentArgs)(args);
+        return this._getAgentPermissionDebug(agentId);
+    }
+    _getAgentPermissionDebug(agentId) {
         return this.rest.get(`/agents/${agentId}/permissions/debug`);
     }
     syncPermissions(body) {