doover-js 0.11.0 → 0.13.0

package/dist/esm/apis/alarms-api.d.ts

@@ -0,0 +1,48 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { Alarm, CreateAlarmRequest, PatchAlarmRequest } from "../types/openapi.js";
+export declare class AlarmsApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    /** Every alarm on every channel of an agent the caller can see. */
+    listAgentAlarms(agentId: string): Promise<Alarm[]>;
+    listAgentAlarms(identifier: {
+        agentId: string;
+    }): Promise<Alarm[]>;
+    private _listAgentAlarms;
+    listAlarms(agentId: string, channelName: string): Promise<Alarm[]>;
+    listAlarms(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<Alarm[]>;
+    private _listAlarms;
+    createAlarm(agentId: string, channelName: string, body: CreateAlarmRequest): Promise<Alarm>;
+    createAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: CreateAlarmRequest): Promise<Alarm>;
+    private _createAlarm;
+    getAlarm(agentId: string, channelName: string, alarmId: string): Promise<Alarm>;
+    getAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string): Promise<Alarm>;
+    private _getAlarm;
+    putAlarm(agentId: string, channelName: string, alarmId: string, body: CreateAlarmRequest): Promise<Alarm>;
+    putAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string, body: CreateAlarmRequest): Promise<Alarm>;
+    private _putAlarm;
+    patchAlarm(agentId: string, channelName: string, alarmId: string, body: PatchAlarmRequest): Promise<Alarm>;
+    patchAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string, body: PatchAlarmRequest): Promise<Alarm>;
+    private _patchAlarm;
+    deleteAlarm(agentId: string, channelName: string, alarmId: string): Promise<unknown>;
+    deleteAlarm(identifier: {
+        agentId: string;
+        channelName: string;
+    }, alarmId: string): Promise<unknown>;
+    private _deleteAlarm;
+}

package/dist/esm/apis/alarms-api.js

@@ -0,0 +1,75 @@
+import { resolveAgentArgs, resolveChannelArgs } from "./_args.js";
+export class AlarmsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    listAgentAlarms(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._listAgentAlarms(agentId);
+    }
+    _listAgentAlarms(agentId) {
+        return this.rest.get(`/agents/${agentId}/alarms`);
+    }
+    listAlarms(...args) {
+        const { agentId, channelName } = resolveChannelArgs(args);
+        return this._listAlarms(agentId, channelName);
+    }
+    _listAlarms(agentId, channelName) {
+        return this.rest.get(`/agents/${agentId}/channels/${channelName}/alarms`);
+    }
+    createAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, body] = args;
+            return this._createAlarm(agentId, channelName, body);
+        }
+        const id = args[0];
+        return this._createAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _createAlarm(agentId, channelName, body) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/alarms`, body);
+    }
+    getAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId] = args;
+            return this._getAlarm(agentId, channelName, alarmId);
+        }
+        const id = args[0];
+        return this._getAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _getAlarm(agentId, channelName, alarmId) {
+        return this.rest.get(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`);
+    }
+    putAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId, body] = args;
+            return this._putAlarm(agentId, channelName, alarmId, body);
+        }
+        const id = args[0];
+        return this._putAlarm(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _putAlarm(agentId, channelName, alarmId, body) {
+        return this.rest.put(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`, body);
+    }
+    patchAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId, body] = args;
+            return this._patchAlarm(agentId, channelName, alarmId, body);
+        }
+        const id = args[0];
+        return this._patchAlarm(id.agentId, id.channelName, args[1], args[2]);
+    }
+    _patchAlarm(agentId, channelName, alarmId, body) {
+        return this.rest.patch(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`, body);
+    }
+    deleteAlarm(...args) {
+        if (typeof args[0] === "string") {
+            const [agentId, channelName, alarmId] = args;
+            return this._deleteAlarm(agentId, channelName, alarmId);
+        }
+        const id = args[0];
+        return this._deleteAlarm(id.agentId, id.channelName, args[1]);
+    }
+    _deleteAlarm(agentId, channelName, alarmId) {
+        return this.rest.delete(`/agents/${agentId}/channels/${channelName}/alarms/${alarmId}`);
+    }
+}

package/dist/esm/apis/channels-api.d.ts

@@ -0,0 +1,83 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { Channel, CreateChannelRequest, DataSeries, PutChannelRequest } from "../types/openapi.js";
+import type { DooverRequestOptions } from "../client/request-options.js";
+export interface ListChannelsOptions {
+    include_aggregate?: boolean;
+    include_daily_summaries?: boolean;
+    include_archived?: boolean;
+}
+export interface GetChannelOptions {
+    include_aggregate?: boolean;
+}
+export interface DataSeriesParams {
+    before?: string;
+    after?: string;
+    limit?: number;
+    field_name: string[];
+}
+export declare class ChannelsApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    listChannels(agentId: string, options?: ListChannelsOptions): Promise<Channel[]>;
+    listChannels(agentId: string, requestOptions: DooverRequestOptions): Promise<Channel[]>;
+    listChannels(agentId: string, options: ListChannelsOptions, requestOptions: DooverRequestOptions): Promise<Channel[]>;
+    listChannels(identifier: {
+        agentId: string;
+    }, options?: ListChannelsOptions): Promise<Channel[]>;
+    listChannels(identifier: {
+        agentId: string;
+    }, requestOptions: DooverRequestOptions): Promise<Channel[]>;
+    listChannels(identifier: {
+        agentId: string;
+    }, options: ListChannelsOptions, requestOptions: DooverRequestOptions): Promise<Channel[]>;
+    private _listChannels;
+    getChannel(agentId: string, channelName: string, options?: GetChannelOptions): Promise<Channel>;
+    getChannel(agentId: string, channelName: string, requestOptions: DooverRequestOptions): Promise<Channel>;
+    getChannel(agentId: string, channelName: string, options: GetChannelOptions, requestOptions: DooverRequestOptions): Promise<Channel>;
+    getChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, options?: GetChannelOptions): Promise<Channel>;
+    getChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, requestOptions: DooverRequestOptions): Promise<Channel>;
+    getChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, options: GetChannelOptions, requestOptions: DooverRequestOptions): Promise<Channel>;
+    private _getChannel;
+    createChannel(agentId: string, channelName: string, body: CreateChannelRequest): Promise<{
+        id: string;
+    }>;
+    createChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: CreateChannelRequest): Promise<{
+        id: string;
+    }>;
+    private _createChannel;
+    putChannel(agentId: string, channelName: string, body: PutChannelRequest): Promise<Channel>;
+    putChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }, body: PutChannelRequest): Promise<Channel>;
+    private _putChannel;
+    archiveChannel(agentId: string, channelName: string): Promise<unknown>;
+    archiveChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<unknown>;
+    private _archiveChannel;
+    unarchiveChannel(agentId: string, channelName: string): Promise<unknown>;
+    unarchiveChannel(identifier: {
+        agentId: string;
+        channelName: string;
+    }): Promise<unknown>;
+    private _unarchiveChannel;
+    listDataSeries(agentId: string, params: DataSeriesParams): Promise<DataSeries>;
+    listDataSeries(identifier: {
+        agentId: string;
+    }, params: DataSeriesParams): Promise<DataSeries>;
+    private _listDataSeries;
+}

package/dist/esm/apis/channels-api.js

@@ -0,0 +1,65 @@
+import { resolveAgentArgs, resolveChannelArgs } from "./_args.js";
+export class ChannelsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    listChannels(...args) {
+        const { agentId, options } = resolveAgentArgs(args);
+        return this._listChannels(agentId, options);
+    }
+    _listChannels(agentId, options) {
+        return this.rest.get(`/agents/${agentId}/channels`, options);
+    }
+    getChannel(...args) {
+        const { agentId, channelName, options } = resolveChannelArgs(args);
+        return this._getChannel(agentId, channelName, options);
+    }
+    _getChannel(agentId, channelName, options) {
+        return this.rest.get(`/agents/${agentId}/channels/${channelName}`, options);
+    }
+    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(...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);
+    }
+    archiveChannel(...args) {
+        const { agentId, channelName } = resolveChannelArgs(args);
+        return this._archiveChannel(agentId, channelName);
+    }
+    _archiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/archive`, {});
+    }
+    unarchiveChannel(...args) {
+        const { agentId, channelName } = resolveChannelArgs(args);
+        return this._unarchiveChannel(agentId, channelName);
+    }
+    _unarchiveChannel(agentId, channelName) {
+        return this.rest.post(`/agents/${agentId}/channels/${channelName}/unarchive`, {});
+    }
+    listDataSeries(...args) {
+        const { agentId, options } = resolveAgentArgs(args);
+        return this._listDataSeries(agentId, options);
+    }
+    _listDataSeries(agentId, params) {
+        return this.rest.get(`/agents/${agentId}/data_series`, params);
+    }
+}

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

@@ -0,0 +1,45 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { ConnectionDetails, ConnectionSubscription, ConnectionSubscriptionLog } from "../types/openapi.js";
+export interface ConnectionHistoryParams {
+    before?: string;
+    after?: string;
+    limit?: number;
+    default_connection?: boolean;
+}
+export interface SubscriptionHistoryParams {
+    before?: string;
+    after?: string;
+    limit?: number;
+    channel: string;
+}
+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[]>;
+    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/esm/apis/connections-api.js

@@ -0,0 +1,44 @@
+import { resolveAgentArgs, resolveChannelArgs } from "./_args.js";
+export class ConnectionsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    getAgentConnections(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._getAgentConnections(agentId);
+    }
+    _getAgentConnections(agentId) {
+        return this.rest.get(`/agents/${agentId}/wss_connections`);
+    }
+    getAgentConnectionHistory(...args) {
+        const { agentId, options } = resolveAgentArgs(args);
+        return this._getAgentConnectionHistory(agentId, options);
+    }
+    _getAgentConnectionHistory(agentId, params) {
+        return this.rest.get(`/agents/${agentId}/wss_connections/history`, params);
+    }
+    getAgentSubscriptionHistory(...args) {
+        const { agentId, options } = 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(...args) {
+        const { agentId, channelName } = resolveChannelArgs(args);
+        return this._getChannelSubscriptions(agentId, channelName);
+    }
+    _getChannelSubscriptions(agentId, channelName) {
+        return this.rest.get(`/agents/${agentId}/channels/${channelName}/subscriptions`);
+    }
+    syncConnection(...args) {
+        const { agentId } = resolveAgentArgs(args);
+        return this._syncConnection(agentId);
+    }
+    _syncConnection(agentId) {
+        return this.rest.post(`/agents/${agentId}/connection_sync`, {});
+    }
+}

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

@@ -0,0 +1,128 @@
+import type { RestClient } from "../http/rest-client.js";
+import type { CreateMessageRequest, DataSeries, MessageStructure, UpdateMessageRequest } from "../types/openapi.js";
+import type { DooverRequestOptions } from "../client/request-options.js";
+import { type BatchCreateMessageItem, type BatchDeleteMessageItem, type BatchMessageResponse, type BatchUpdateMessageItem } from "../types/batch.js";
+export interface ListMessagesParams {
+    before?: string;
+    /**
+     * Lower-bound cursor (exclusive). With `before` set (or defaulted) it merely
+     * floors the window. On its own — `after` set, `before` omitted — it pages
+     * *forward*: the server returns the `limit` **oldest** messages strictly
+     * newer than the cursor, oldest-first. This is the only way to walk history
+     * upward toward "now".
+     */
+    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";
+    /**
+     * Opt into paginated timeseries responses (`getTimeseries` only). When true
+     * the server returns a `next` cursor alongside `{ results, count }`; pass it
+     * back as `before` to page through results.
+     */
+    paginate?: boolean;
+}
+export interface MessageMutationParams {
+    suppress_response?: boolean;
+    clear_attachments?: boolean;
+}
+export type MessageBody = CreateMessageRequest | UpdateMessageRequest | FormData;
+export declare class MessagesApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    listMessages(agentId: string, channelName: string, params?: ListMessagesParams): Promise<MessageStructure[]>;
+    listMessages(agentId: string, channelName: string, params: ListMessagesParams, requestOptions: DooverRequestOptions): Promise<MessageStructure[]>;
+    listMessages(identifier: {
+        agentId: string;
+        channelName: string;
+    }, params?: ListMessagesParams): Promise<MessageStructure[]>;
+    listMessages(identifier: {
+        agentId: string;
+        channelName: string;
+    }, params: ListMessagesParams, requestOptions: DooverRequestOptions): 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>;
+    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;
+    /**
+     * Create messages across many agents and channels in one request.
+     *
+     * Supply `message_id` per item where you can: the server's create path is
+     * not yet idempotent, so a retry after a lost response can otherwise
+     * duplicate the message and double-count the daily summary.
+     */
+    batchPostMessages(items: BatchCreateMessageItem[]): Promise<BatchMessageResponse>;
+    batchPostMessages(items: BatchCreateMessageItem[], requestOptions: DooverRequestOptions): Promise<BatchMessageResponse>;
+    /** Merge-patch messages across many agents and channels in one request. */
+    batchPatchMessages(items: BatchUpdateMessageItem[]): Promise<BatchMessageResponse>;
+    batchPatchMessages(items: BatchUpdateMessageItem[], requestOptions: DooverRequestOptions): Promise<BatchMessageResponse>;
+    /** Replace messages across many agents and channels in one request. */
+    batchPutMessages(items: BatchUpdateMessageItem[]): Promise<BatchMessageResponse>;
+    batchPutMessages(items: BatchUpdateMessageItem[], requestOptions: DooverRequestOptions): Promise<BatchMessageResponse>;
+    /**
+     * Delete messages across many agents and channels in one request.
+     *
+     * Deletion is not idempotent server-side yet — a retried delete can
+     * decrement the daily summary twice — so retry only items the response
+     * reported as failed.
+     */
+    batchDeleteMessages(items: BatchDeleteMessageItem[]): Promise<BatchMessageResponse>;
+    batchDeleteMessages(items: BatchDeleteMessageItem[], requestOptions: DooverRequestOptions): Promise<BatchMessageResponse>;
+    /**
+     * Shared driver for the four `/agents/messages` verbs. Chunks to the
+     * server's item ceiling and sends sequentially, so a long list doesn't
+     * reintroduce the burst that batching exists to remove.
+     */
+    private _batchMessages;
+    createMultipartPayload(jsonPayload: Record<string, unknown>, attachments: Array<Blob | File>): FormData;
+}

package/dist/esm/apis/messages-api.js

@@ -0,0 +1,179 @@
+import { addTimestampToMessage, generateSnowflakeIdAtTime } from "../utils/snowflake.js";
+import { resolveChannelArgs } from "./_args.js";
+import { chunkBatchItems, mergeBatchResponses, } from "../types/batch.js";
+function resolveListMessagesParams(params) {
+    const order = params?.order ?? "desc";
+    const hasAfter = params?.after !== undefined;
+    const hasBefore = params?.before !== undefined;
+    // The server keys pagination on whichever bound is sent: `before` walks
+    // newest-first downward, `after` alone walks oldest-first upward (the N
+    // oldest messages strictly newer than the cursor). Sending `after` without
+    // `before` is the only way to page forward; sending both, or neither, keeps
+    // the newest-first behaviour (defaulting `before` to "now" when unbounded).
+    if (hasAfter && !hasBefore) {
+        const query = {
+            after: params.after,
+            limit: params?.limit ?? 10,
+        };
+        if (params?.field_name !== undefined)
+            query.field_name = params.field_name;
+        return { query, order, serverAscending: true };
+    }
+    const query = {
+        before: params?.before ?? generateSnowflakeIdAtTime(new Date()),
+        limit: params?.limit ?? 10,
+    };
+    if (hasAfter)
+        query.after = params.after;
+    if (params?.field_name !== undefined)
+        query.field_name = params.field_name;
+    return { query, order, serverAscending: false };
+}
+export class MessagesApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    async listMessages(...args) {
+        const { agentId, channelName, options } = resolveChannelArgs(args);
+        return this._listMessages(agentId, channelName, options);
+    }
+    async _listMessages(agentId, channelName, params) {
+        const { query, order, serverAscending } = resolveListMessagesParams(params);
+        const response = await this.rest.get(`/agents/${agentId}/channels/${channelName}/messages`, query);
+        const stamped = response.map(addTimestampToMessage);
+        // The server returns newest-first for `before` and oldest-first for a bare
+        // `after`; reverse only when that native order differs from what was asked.
+        const wantAscending = order === "asc";
+        return serverAscending === wantAscending ? stamped : [...stamped].reverse();
+    }
+    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) {
+        const response = await this.rest.post(`/agents/${agentId}/channels/${channelName}/messages`, body);
+        return addTimestampToMessage(response);
+    }
+    getTimeseries(...args) {
+        const { agentId, channelName, options } = 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) {
+        const response = await this.rest.get(`/agents/${agentId}/channels/${channelName}/messages/${messageId}`);
+        return addTimestampToMessage(response);
+    }
+    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(...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(...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(...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(...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`);
+    }
+    batchPostMessages(...args) {
+        return this._batchMessages("POST", args[0]);
+    }
+    batchPatchMessages(...args) {
+        return this._batchMessages("PATCH", args[0]);
+    }
+    batchPutMessages(...args) {
+        return this._batchMessages("PUT", args[0]);
+    }
+    batchDeleteMessages(...args) {
+        return this._batchMessages("DELETE", args[0]);
+    }
+    /**
+     * Shared driver for the four `/agents/messages` verbs. Chunks to the
+     * server's item ceiling and sends sequentially, so a long list doesn't
+     * reintroduce the burst that batching exists to remove.
+     */
+    async _batchMessages(method, items) {
+        if (items.length === 0) {
+            return { items: [], count: 0, succeeded: 0, failed: 0 };
+        }
+        const responses = [];
+        for (const chunk of chunkBatchItems(items)) {
+            // Goes through `request` rather than the verb helpers because DELETE
+            // needs a body, which `rest.delete` does not accept.
+            responses.push(await this.rest.request({
+                path: "/agents/messages",
+                method,
+                body: { items: chunk },
+            }));
+        }
+        return mergeBatchResponses(responses);
+    }
+    createMultipartPayload(jsonPayload, attachments) {
+        const formData = new FormData();
+        formData.set("json_payload", JSON.stringify(jsonPayload));
+        attachments.forEach((attachment, index) => {
+            formData.set(`attachment-${index}`, attachment);
+        });
+        return formData;
+    }
+}