@jimiford/channel-webex 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * OpenClaw Webex Channel Plugin
+ *
+ * A channel plugin for integrating Cisco Webex messaging with OpenClaw.
+ *
+ * @packageDocumentation
+ */
+export { WebexChannel, createWebexChannel, createAndInitialize } from './channel';
+export { WebexSender, WebexApiRequestError } from './send';
+export { WebexWebhookHandler, WebhookValidationError } from './webhook';
+export type { WebexChannelConfig, DmPolicy, WebexPerson, WebexRoom, WebexMessage, WebexAttachment, AdaptiveCard, WebexWebhook, WebexWebhookResource, WebexWebhookEvent, WebexWebhookPayload, WebexWebhookData, CreateMessageRequest, CreateWebhookRequest, WebexApiError, PaginatedResponse, OpenClawEnvelope, OpenClawAttachment, OpenClawOutboundMessage, WebexChannelPlugin, WebhookHandler, RetryOptions, RequestOptions, } from './types';
+import { createWebexChannel } from './channel';
+export default createWebexChannel;
+/**
+ * Plugin metadata for OpenClaw discovery
+ */
+export declare const pluginMetadata: {
+    name: string;
+    version: string;
+    type: string;
+    channel: string;
+    description: string;
+    author: string;
+    repository: string;
+    capabilities: {
+        dm: boolean;
+        groups: boolean;
+        threads: boolean;
+        attachments: boolean;
+        cards: boolean;
+        webhooks: boolean;
+    };
+};

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * OpenClaw Webex Channel Plugin
+ *
+ * A channel plugin for integrating Cisco Webex messaging with OpenClaw.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginMetadata = exports.WebhookValidationError = exports.WebexWebhookHandler = exports.WebexApiRequestError = exports.WebexSender = exports.createAndInitialize = exports.createWebexChannel = exports.WebexChannel = void 0;
+// Main channel export
+var channel_1 = require("./channel");
+Object.defineProperty(exports, "WebexChannel", { enumerable: true, get: function () { return channel_1.WebexChannel; } });
+Object.defineProperty(exports, "createWebexChannel", { enumerable: true, get: function () { return channel_1.createWebexChannel; } });
+Object.defineProperty(exports, "createAndInitialize", { enumerable: true, get: function () { return channel_1.createAndInitialize; } });
+// Sender export
+var send_1 = require("./send");
+Object.defineProperty(exports, "WebexSender", { enumerable: true, get: function () { return send_1.WebexSender; } });
+Object.defineProperty(exports, "WebexApiRequestError", { enumerable: true, get: function () { return send_1.WebexApiRequestError; } });
+// Webhook handler export
+var webhook_1 = require("./webhook");
+Object.defineProperty(exports, "WebexWebhookHandler", { enumerable: true, get: function () { return webhook_1.WebexWebhookHandler; } });
+Object.defineProperty(exports, "WebhookValidationError", { enumerable: true, get: function () { return webhook_1.WebhookValidationError; } });
+// Default export: factory function
+const channel_2 = require("./channel");
+exports.default = channel_2.createWebexChannel;
+/**
+ * Plugin metadata for OpenClaw discovery
+ */
+exports.pluginMetadata = {
+    name: '@openclaw/channel-webex',
+    version: '1.0.0',
+    type: 'channel',
+    channel: 'webex',
+    description: 'Cisco Webex messaging channel plugin for OpenClaw',
+    author: 'OpenClaw Contributors',
+    repository: 'https://github.com/openclaw/channel-webex',
+    capabilities: {
+        dm: true,
+        groups: true,
+        threads: true,
+        attachments: true,
+        cards: true,
+        webhooks: true,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/send.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Webex Message Sending Module
+ */
+import type { WebexChannelConfig, WebexMessage, OpenClawOutboundMessage } from './types';
+export declare class WebexSender {
+    private config;
+    private apiBaseUrl;
+    private retryOptions;
+    constructor(config: WebexChannelConfig);
+    /**
+     * Send a message to Webex
+     */
+    send(message: OpenClawOutboundMessage): Promise<WebexMessage>;
+    /**
+     * Send a text message to a room
+     */
+    sendToRoom(roomId: string, text: string, markdown?: string): Promise<WebexMessage>;
+    /**
+     * Send a direct message to a person by ID
+     */
+    sendDirectById(personId: string, text: string, markdown?: string): Promise<WebexMessage>;
+    /**
+     * Send a direct message to a person by email
+     */
+    sendDirectByEmail(email: string, text: string, markdown?: string): Promise<WebexMessage>;
+    /**
+     * Send a message with file attachment
+     */
+    sendWithFile(roomId: string, text: string, fileUrl: string): Promise<WebexMessage>;
+    /**
+     * Send a threaded reply
+     */
+    sendReply(roomId: string, parentId: string, text: string, markdown?: string): Promise<WebexMessage>;
+    /**
+     * Get a message by ID
+     */
+    getMessage(messageId: string): Promise<WebexMessage>;
+    /**
+     * Delete a message by ID
+     */
+    deleteMessage(messageId: string): Promise<void>;
+    /**
+     * Build a Webex message request from an OpenClaw outbound message
+     */
+    private buildMessageRequest;
+    /**
+     * Create a message via the Webex API
+     */
+    private createMessage;
+    /**
+     * Validate a message request before sending
+     */
+    private validateMessageRequest;
+    /**
+     * Make an API request with retry logic
+     */
+    private request;
+    /**
+     * Execute a single API request
+     */
+    private executeRequest;
+    /**
+     * Parse error response from Webex API
+     */
+    private parseErrorResponse;
+    /**
+     * Determine if a request should be retried
+     */
+    private shouldRetry;
+    /**
+     * Calculate backoff delay with exponential backoff and jitter
+     */
+    private calculateBackoff;
+    /**
+     * Sleep for a given number of milliseconds
+     */
+    private sleep;
+}
+/**
+ * Custom error class for Webex API errors
+ */
+export declare class WebexApiRequestError extends Error {
+    readonly statusCode: number;
+    readonly trackingId?: string;
+    readonly details?: Array<{
+        description: string;
+    }>;
+    constructor(message: string, statusCode: number, trackingId?: string, details?: Array<{
+        description: string;
+    }>);
+    toJSON(): object;
+}

package/dist/send.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Webex Message Sending Module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebexApiRequestError = exports.WebexSender = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+// Rate limit status codes that should trigger retry
+const RETRY_STATUS_CODES = [429, 502, 503, 504];
+class WebexSender {
+    config;
+    apiBaseUrl;
+    retryOptions;
+    constructor(config) {
+        this.config = config;
+        this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;
+        this.retryOptions = {
+            maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+            retryDelayMs: config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
+        };
+    }
+    /**
+     * Send a message to Webex
+     */
+    async send(message) {
+        const request = this.buildMessageRequest(message);
+        return this.createMessage(request);
+    }
+    /**
+     * Send a text message to a room
+     */
+    async sendToRoom(roomId, text, markdown) {
+        return this.createMessage({
+            roomId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a direct message to a person by ID
+     */
+    async sendDirectById(personId, text, markdown) {
+        return this.createMessage({
+            toPersonId: personId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a direct message to a person by email
+     */
+    async sendDirectByEmail(email, text, markdown) {
+        return this.createMessage({
+            toPersonEmail: email,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a message with file attachment
+     */
+    async sendWithFile(roomId, text, fileUrl) {
+        return this.createMessage({
+            roomId,
+            text,
+            files: [fileUrl],
+        });
+    }
+    /**
+     * Send a threaded reply
+     */
+    async sendReply(roomId, parentId, text, markdown) {
+        return this.createMessage({
+            roomId,
+            parentId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Get a message by ID
+     */
+    async getMessage(messageId) {
+        return this.request({
+            method: 'GET',
+            path: `/messages/${messageId}`,
+        });
+    }
+    /**
+     * Delete a message by ID
+     */
+    async deleteMessage(messageId) {
+        await this.request({
+            method: 'DELETE',
+            path: `/messages/${messageId}`,
+        });
+    }
+    /**
+     * Build a Webex message request from an OpenClaw outbound message
+     */
+    buildMessageRequest(message) {
+        const request = {};
+        // Determine target: roomId, personId, or email
+        const to = message.to;
+        if (to.includes('@')) {
+            request.toPersonEmail = to;
+        }
+        else if (to.startsWith('Y2lzY29zcGFyazovL3')) {
+            // Base64-encoded Webex IDs start with this prefix
+            if (to.includes('ROOM')) {
+                request.roomId = to;
+            }
+            else {
+                request.toPersonId = to;
+            }
+        }
+        else {
+            // Assume it's a roomId if not an email
+            request.roomId = to;
+        }
+        // Set content
+        if (message.content.text) {
+            request.text = message.content.text;
+        }
+        if (message.content.markdown) {
+            request.markdown = message.content.markdown;
+        }
+        if (message.content.files && message.content.files.length > 0) {
+            // Webex only allows one file per message
+            request.files = [message.content.files[0]];
+        }
+        if (message.content.card) {
+            request.attachments = [
+                {
+                    contentType: 'application/vnd.microsoft.card.adaptive',
+                    content: message.content.card,
+                },
+            ];
+        }
+        // Set threading
+        if (message.parentId) {
+            request.parentId = message.parentId;
+        }
+        return request;
+    }
+    /**
+     * Create a message via the Webex API
+     */
+    async createMessage(request) {
+        this.validateMessageRequest(request);
+        return this.request({
+            method: 'POST',
+            path: '/messages',
+            body: request,
+        });
+    }
+    /**
+     * Validate a message request before sending
+     */
+    validateMessageRequest(request) {
+        // Must have a target
+        if (!request.roomId && !request.toPersonId && !request.toPersonEmail) {
+            throw new Error('Message must have a target: roomId, toPersonId, or toPersonEmail');
+        }
+        // Must have content
+        if (!request.text && !request.markdown && !request.files?.length && !request.attachments?.length) {
+            throw new Error('Message must have content: text, markdown, files, or attachments');
+        }
+        // Text has a max size of 7439 bytes
+        if (request.text && Buffer.byteLength(request.text, 'utf8') > 7439) {
+            throw new Error('Message text exceeds maximum size of 7439 bytes');
+        }
+    }
+    /**
+     * Make an API request with retry logic
+     */
+    async request(options) {
+        let lastError = null;
+        let attempt = 0;
+        while (attempt <= this.retryOptions.maxRetries) {
+            try {
+                return await this.executeRequest(options);
+            }
+            catch (error) {
+                lastError = error;
+                attempt++;
+                if (attempt > this.retryOptions.maxRetries) {
+                    break;
+                }
+                if (!this.shouldRetry(error, attempt)) {
+                    break;
+                }
+                // Exponential backoff with jitter
+                const delay = this.calculateBackoff(attempt);
+                await this.sleep(delay);
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+    /**
+     * Execute a single API request
+     */
+    async executeRequest(options) {
+        const url = `${this.apiBaseUrl}${options.path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.config.token}`,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        const response = await (0, node_fetch_1.default)(url, {
+            method: options.method,
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const error = await this.parseErrorResponse(response);
+            throw error;
+        }
+        // DELETE requests return 204 No Content
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    /**
+     * Parse error response from Webex API
+     */
+    async parseErrorResponse(response) {
+        let errorData = null;
+        try {
+            errorData = await response.json();
+        }
+        catch {
+            // Response body might not be JSON
+        }
+        const message = errorData?.message || `HTTP ${response.status}: ${response.statusText}`;
+        const error = new WebexApiRequestError(message, response.status, errorData?.trackingId, errorData?.errors);
+        return error;
+    }
+    /**
+     * Determine if a request should be retried
+     */
+    shouldRetry(error, attempt) {
+        if (error instanceof WebexApiRequestError) {
+            return RETRY_STATUS_CODES.includes(error.statusCode);
+        }
+        // Retry network errors
+        return error.message.includes('ECONNRESET') ||
+            error.message.includes('ETIMEDOUT') ||
+            error.message.includes('ENOTFOUND');
+    }
+    /**
+     * Calculate backoff delay with exponential backoff and jitter
+     */
+    calculateBackoff(attempt) {
+        const baseDelay = this.retryOptions.retryDelayMs;
+        const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+        const jitter = Math.random() * 0.3 * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, 30000); // Cap at 30 seconds
+    }
+    /**
+     * Sleep for a given number of milliseconds
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.WebexSender = WebexSender;
+/**
+ * Custom error class for Webex API errors
+ */
+class WebexApiRequestError extends Error {
+    statusCode;
+    trackingId;
+    details;
+    constructor(message, statusCode, trackingId, details) {
+        super(message);
+        this.name = 'WebexApiRequestError';
+        this.statusCode = statusCode;
+        this.trackingId = trackingId;
+        this.details = details;
+        // Maintains proper stack trace for where error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, WebexApiRequestError);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            trackingId: this.trackingId,
+            details: this.details,
+        };
+    }
+}
+exports.WebexApiRequestError = WebexApiRequestError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Webex Message Sending Module\n */\n\nimport fetch, { Response } from 'node-fetch';\nimport type {\n  WebexChannelConfig,\n  WebexMessage,\n  CreateMessageRequest,\n  OpenClawOutboundMessage,\n  WebexApiError,\n  RetryOptions,\n  RequestOptions,\n} from './types';\n\nconst DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';\nconst DEFAULT_MAX_RETRIES = 3;\nconst DEFAULT_RETRY_DELAY_MS = 1000;\n\n// Rate limit status codes that should trigger retry\nconst RETRY_STATUS_CODES = [429, 502, 503, 504];\n\nexport class WebexSender {\n  private config: WebexChannelConfig;\n  private apiBaseUrl: string;\n  private retryOptions: RetryOptions;\n\n  constructor(config: WebexChannelConfig) {\n    this.config = config;\n    this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;\n    this.retryOptions = {\n      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,\n      retryDelayMs: config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n  }\n\n  /**\n   * Send a message to Webex\n   */\n  async send(message: OpenClawOutboundMessage): Promise<WebexMessage> {\n    const request = this.buildMessageRequest(message);\n    return this.createMessage(request);\n  }\n\n  /**\n   * Send a text message to a room\n   */\n  async sendToRoom(roomId: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a direct message to a person by ID\n   */\n  async sendDirectById(personId: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      toPersonId: personId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a direct message to a person by email\n   */\n  async sendDirectByEmail(email: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      toPersonEmail: email,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a message with file attachment\n   */\n  async sendWithFile(\n    roomId: string,\n    text: string,\n    fileUrl: string\n  ): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      text,\n      files: [fileUrl],\n    });\n  }\n\n  /**\n   * Send a threaded reply\n   */\n  async sendReply(\n    roomId: string,\n    parentId: string,\n    text: string,\n    markdown?: string\n  ): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      parentId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Get a message by ID\n   */\n  async getMessage(messageId: string): Promise<WebexMessage> {\n    return this.request<WebexMessage>({\n      method: 'GET',\n      path: `/messages/${messageId}`,\n    });\n  }\n\n  /**\n   * Delete a message by ID\n   */\n  async deleteMessage(messageId: string): Promise<void> {\n    await this.request<void>({\n      method: 'DELETE',\n      path: `/messages/${messageId}`,\n    });\n  }\n\n  /**\n   * Build a Webex message request from an OpenClaw outbound message\n   */\n  private buildMessageRequest(message: OpenClawOutboundMessage): CreateMessageRequest {\n    const request: CreateMessageRequest = {};\n\n    // Determine target: roomId, personId, or email\n    const to = message.to;\n    if (to.includes('@')) {\n      request.toPersonEmail = to;\n    } else if (to.startsWith('Y2lzY29zcGFyazovL3')) {\n      // Base64-encoded Webex IDs start with this prefix\n      if (to.includes('ROOM')) {\n        request.roomId = to;\n      } else {\n        request.toPersonId = to;\n      }\n    } else {\n      // Assume it's a roomId if not an email\n      request.roomId = to;\n    }\n\n    // Set content\n    if (message.content.text) {\n      request.text = message.content.text;\n    }\n    if (message.content.markdown) {\n      request.markdown = message.content.markdown;\n    }\n    if (message.content.files && message.content.files.length > 0) {\n      // Webex only allows one file per message\n      request.files = [message.content.files[0]];\n    }\n    if (message.content.card) {\n      request.attachments = [\n        {\n          contentType: 'application/vnd.microsoft.card.adaptive',\n          content: message.content.card,\n        },\n      ];\n    }\n\n    // Set threading\n    if (message.parentId) {\n      request.parentId = message.parentId;\n    }\n\n    return request;\n  }\n\n  /**\n   * Create a message via the Webex API\n   */\n  private async createMessage(request: CreateMessageRequest): Promise<WebexMessage> {\n    this.validateMessageRequest(request);\n\n    return this.request<WebexMessage>({\n      method: 'POST',\n      path: '/messages',\n      body: request,\n    });\n  }\n\n  /**\n   * Validate a message request before sending\n   */\n  private validateMessageRequest(request: CreateMessageRequest): void {\n    // Must have a target\n    if (!request.roomId && !request.toPersonId && !request.toPersonEmail) {\n      throw new Error('Message must have a target: roomId, toPersonId, or toPersonEmail');\n    }\n\n    // Must have content\n    if (!request.text && !request.markdown && !request.files?.length && !request.attachments?.length) {\n      throw new Error('Message must have content: text, markdown, files, or attachments');\n    }\n\n    // Text has a max size of 7439 bytes\n    if (request.text && Buffer.byteLength(request.text, 'utf8') > 7439) {\n      throw new Error('Message text exceeds maximum size of 7439 bytes');\n    }\n  }\n\n  /**\n   * Make an API request with retry logic\n   */\n  private async request<T>(options: RequestOptions): Promise<T> {\n    let lastError: Error | null = null;\n    let attempt = 0;\n\n    while (attempt <= this.retryOptions.maxRetries) {\n      try {\n        return await this.executeRequest<T>(options);\n      } catch (error) {\n        lastError = error as Error;\n        attempt++;\n\n        if (attempt > this.retryOptions.maxRetries) {\n          break;\n        }\n\n        if (!this.shouldRetry(error as Error, attempt)) {\n          break;\n        }\n\n        // Exponential backoff with jitter\n        const delay = this.calculateBackoff(attempt);\n        await this.sleep(delay);\n      }\n    }\n\n    throw lastError || new Error('Request failed after retries');\n  }\n\n  /**\n   * Execute a single API request\n   */\n  private async executeRequest<T>(options: RequestOptions): Promise<T> {\n    const url = `${this.apiBaseUrl}${options.path}`;\n    const headers: Record<string, string> = {\n      'Authorization': `Bearer ${this.config.token}`,\n      'Content-Type': 'application/json',\n      ...options.headers,\n    };\n\n    const response = await fetch(url, {\n      method: options.method,\n      headers,\n      body: options.body ? JSON.stringify(options.body) : undefined,\n    });\n\n    if (!response.ok) {\n      const error = await this.parseErrorResponse(response);\n      throw error;\n    }\n\n    // DELETE requests return 204 No Content\n    if (response.status === 204) {\n      return undefined as T;\n    }\n\n    return response.json() as Promise<T>;\n  }\n\n  /**\n   * Parse error response from Webex API\n   */\n  private async parseErrorResponse(response: Response): Promise<Error> {\n    let errorData: WebexApiError | null = null;\n\n    try {\n      errorData = await response.json() as WebexApiError;\n    } catch {\n      // Response body might not be JSON\n    }\n\n    const message = errorData?.message || `HTTP ${response.status}: ${response.statusText}`;\n    const error = new WebexApiRequestError(\n      message,\n      response.status,\n      errorData?.trackingId,\n      errorData?.errors\n    );\n\n    return error;\n  }\n\n  /**\n   * Determine if a request should be retried\n   */\n  private shouldRetry(error: Error, attempt: number): boolean {\n    if (error instanceof WebexApiRequestError) {\n      return RETRY_STATUS_CODES.includes(error.statusCode);\n    }\n    // Retry network errors\n    return error.message.includes('ECONNRESET') ||\n           error.message.includes('ETIMEDOUT') ||\n           error.message.includes('ENOTFOUND');\n  }\n\n  /**\n   * Calculate backoff delay with exponential backoff and jitter\n   */\n  private calculateBackoff(attempt: number): number {\n    const baseDelay = this.retryOptions.retryDelayMs;\n    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);\n    const jitter = Math.random() * 0.3 * exponentialDelay;\n    return Math.min(exponentialDelay + jitter, 30000); // Cap at 30 seconds\n  }\n\n  /**\n   * Sleep for a given number of milliseconds\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Custom error class for Webex API errors\n */\nexport class WebexApiRequestError extends Error {\n  readonly statusCode: number;\n  readonly trackingId?: string;\n  readonly details?: Array<{ description: string }>;\n\n  constructor(\n    message: string,\n    statusCode: number,\n    trackingId?: string,\n    details?: Array<{ description: string }>\n  ) {\n    super(message);\n    this.name = 'WebexApiRequestError';\n    this.statusCode = statusCode;\n    this.trackingId = trackingId;\n    this.details = details;\n\n    // Maintains proper stack trace for where error was thrown\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, WebexApiRequestError);\n    }\n  }\n\n  toJSON(): object {\n    return {\n      name: this.name,\n      message: this.message,\n      statusCode: this.statusCode,\n      trackingId: this.trackingId,\n      details: this.details,\n    };\n  }\n}\n"]}