@vybit/n8n-nodes-vybit 2.0.0

package/dist/nodes/Vybit/Vybit.node.js

@@ -0,0 +1,1789 @@
+var dist$1 = {};
+
+var apiClient = {};
+
+var dist = {};
+
+var types$1 = {};
+
+Object.defineProperty(types$1, "__esModule", { value: true });
+
+var utils = {};
+
+Object.defineProperty(utils, "__esModule", { value: true });
+utils.isValidUrl = isValidUrl;
+utils.generateRandomState = generateRandomState;
+utils.buildQueryString = buildQueryString;
+utils.getDefaultBaseUrl = getDefaultBaseUrl;
+utils.getAuthDomain = getAuthDomain;
+utils.getApiBaseUrl = getApiBaseUrl;
+function isValidUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function generateRandomState(length = 12) {
+  let result = "";
+  while (result.length < length) {
+    result += Math.random().toString(36).substring(2);
+  }
+  return result.substring(0, length);
+}
+function buildQueryString(params) {
+  return new URLSearchParams(params).toString();
+}
+function getDefaultBaseUrl() {
+  return "https://vybit.net";
+}
+function getAuthDomain() {
+  return "https://app.vybit.net";
+}
+function getApiBaseUrl() {
+  return "https://api.vybit.net/v1";
+}
+
+var errors = {};
+
+Object.defineProperty(errors, "__esModule", { value: true });
+errors.VybitValidationError = errors.VybitAPIError = errors.VybitAuthError = errors.VybitSDKError = void 0;
+class VybitSDKError extends Error {
+  constructor(message, code = "UNKNOWN_ERROR", details) {
+    super(message);
+    this.name = "VybitSDKError";
+    this.code = code;
+    this.details = details;
+  }
+}
+errors.VybitSDKError = VybitSDKError;
+class VybitAuthError extends VybitSDKError {
+  constructor(message, statusCode, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "VybitAuthError";
+    this.statusCode = statusCode;
+  }
+}
+errors.VybitAuthError = VybitAuthError;
+class VybitAPIError extends VybitSDKError {
+  constructor(message, statusCode, details) {
+    super(message, "API_ERROR", details);
+    this.name = "VybitAPIError";
+    this.statusCode = statusCode;
+  }
+}
+errors.VybitAPIError = VybitAPIError;
+class VybitValidationError extends VybitSDKError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "VybitValidationError";
+  }
+}
+errors.VybitValidationError = VybitValidationError;
+
+(function (exports$1) {
+	var __createBinding = this && this.__createBinding || (Object.create ? (function(o, m, k, k2) {
+	  if (k2 === void 0) k2 = k;
+	  var desc = Object.getOwnPropertyDescriptor(m, k);
+	  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	    desc = { enumerable: true, get: function() {
+	      return m[k];
+	    } };
+	  }
+	  Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	  if (k2 === void 0) k2 = k;
+	  o[k2] = m[k];
+	}));
+	var __exportStar = this && this.__exportStar || function(m, exports2) {
+	  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	__exportStar(types$1, exports$1);
+	__exportStar(utils, exports$1);
+	__exportStar(errors, exports$1); 
+} (dist));
+
+Object.defineProperty(apiClient, "__esModule", { value: true });
+apiClient.VybitAPIClient = void 0;
+const core_1 = dist;
+class VybitAPIClient {
+  /**
+   * Creates a new Vybit Developer API client
+   * @param config - API configuration. If apiKey is not provided, falls back to VYBIT_API_KEY environment variable
+   * @throws {VybitValidationError} When API key is not provided and VYBIT_API_KEY environment variable is not set
+   */
+  constructor(config = {}) {
+    const apiKey = config.apiKey || void 0;
+    if (!apiKey) {
+      throw new core_1.VybitValidationError("API key is required. Provide it in the config or set VYBIT_API_KEY environment variable");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = config.baseUrl || (0, core_1.getApiBaseUrl)();
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      ...options.headers
+    };
+    if (options.body && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new core_1.VybitAuthError("Invalid or missing API key", response.status);
+        }
+        if (response.status === 429) {
+          throw new core_1.VybitAPIError("Rate limit exceeded", response.status);
+        }
+        const errorData = await response.json().catch(() => ({}));
+        if (response.status === 403 && errorData.error === "vybit_limit_reached") {
+          throw new core_1.VybitAPIError("Vybit limit reached for your tier. Delete existing vybits or upgrade your account.", response.status);
+        }
+        throw new core_1.VybitAPIError(errorData.message || errorData.error || `API request failed: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof core_1.VybitAPIError || error instanceof core_1.VybitAuthError) {
+        throw error;
+      }
+      throw new core_1.VybitAPIError(`Network error: ${error}`);
+    }
+  }
+  buildQueryParams(params) {
+    if (!params)
+      return "";
+    const query = new URLSearchParams();
+    if (params.offset !== void 0)
+      query.append("offset", String(params.offset));
+    if (params.limit !== void 0)
+      query.append("limit", String(params.limit));
+    if ("search" in params && params.search)
+      query.append("search", params.search);
+    const queryString = query.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  // ==================== Status & Utility ====================
+  /**
+   * Check API health status
+   * @returns API status response
+   */
+  async getStatus() {
+    return this.request("/status");
+  }
+  /**
+   * Get usage metrics and tier limits
+   * @returns Usage statistics and capacity limits
+   */
+  async getMeter() {
+    return this.request("/meter");
+  }
+  // ==================== Profile ====================
+  /**
+   * Get user profile information
+   * @returns User profile data
+   */
+  async getProfile() {
+    return this.request("/profile");
+  }
+  // ==================== Vybits ====================
+  /**
+   * List vybits owned by the authenticated user
+   * @param params - Pagination and search parameters
+   * @returns Array of vybits
+   */
+  async listVybits(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/vybits${query}`);
+  }
+  /**
+   * Get a specific vybit by key
+   * @param key - Vybit key
+   * @returns Vybit details
+   */
+  async getVybit(key) {
+    return this.request(`/vybit/${key}`);
+  }
+  /**
+   * Create a new vybit
+   * @param params - Vybit creation parameters
+   * @returns Created vybit
+   */
+  async createVybit(params) {
+    return this.request("/vybit", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Update a vybit (full update)
+   * @param key - Vybit key
+   * @param params - Vybit update parameters
+   * @returns Updated vybit
+   */
+  async updateVybit(key, params) {
+    return this.request(`/vybit/${key}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Update a vybit (partial update)
+   * @param key - Vybit key
+   * @param params - Vybit update parameters
+   * @returns Updated vybit
+   */
+  async patchVybit(key, params) {
+    return this.request(`/vybit/${key}`, {
+      method: "PATCH",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete a vybit
+   * @param key - Vybit key
+   * @returns Delete confirmation
+   */
+  async deleteVybit(key) {
+    return this.request(`/vybit/${key}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Trigger a vybit notification as the owner
+   * @param key - Vybit key
+   * @param params - Optional notification content to override defaults
+   * @returns Trigger response with log key
+   *
+   * @example
+   * ```typescript
+   * const result = await client.triggerVybit('vybit123abc', {
+   *   message: 'Server maintenance complete',
+   *   imageUrl: 'https://example.com/status-ok.jpg'
+   * });
+   * console.log('Notification triggered, log key:', result.plk);
+   * ```
+   */
+  async triggerVybit(key, params) {
+    return this.request(`/vybit/${key}/trigger`, {
+      method: "POST",
+      body: params ? JSON.stringify(params) : void 0
+    });
+  }
+  // ==================== Subscriptions ====================
+  /**
+   * List public vybits available for subscription
+   * @param params - Pagination and search parameters
+   * @returns Array of public vybits
+   */
+  async listPublicVybits(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/subscriptions/public${query}`);
+  }
+  /**
+   * Get a public vybit by subscription key
+   * @param key - Subscription key
+   * @returns Public vybit details
+   */
+  async getPublicVybit(key) {
+    return this.request(`/subscription/${key}`);
+  }
+  // ==================== Vybit Subscriptions (Follows) ====================
+  /**
+   * List vybit subscriptions (follows)
+   * @param params - Pagination and search parameters
+   * @returns Array of vybit follows
+   */
+  async listVybitFollows(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/subscriptions/following${query}`);
+  }
+  /**
+   * Get a specific vybit follow by key
+   * @param key - Vybit follow (following) key
+   * @returns Vybit follow details
+   */
+  async getVybitFollow(key) {
+    return this.request(`/subscription/following/${key}`);
+  }
+  /**
+   * Subscribe to a vybit using its subscription key
+   * @param subscriptionKey - The subscription key of the vybit to subscribe to
+   * @returns Created vybit follow
+   */
+  async createVybitFollow(subscriptionKey) {
+    return this.request(`/subscription/${subscriptionKey}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Update a vybit subscription
+   * @param key - Vybit follow (following) key
+   * @param params - Update parameters
+   * @returns Updated vybit follow
+   */
+  async updateVybitFollow(key, params) {
+    return this.request(`/subscription/following/${key}`, {
+      method: "PATCH",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Unsubscribe from a vybit (delete follow)
+   * @param key - Vybit follow (following) key
+   * @returns Delete confirmation
+   */
+  async deleteVybitFollow(key) {
+    return this.request(`/subscription/following/${key}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Send a notification to the owner of a subscribed vybit
+   *
+   * Only available when the vybit's sendPermissions is set to 'subs_owner'.
+   * The subscription must be active (status='on') and granted access.
+   *
+   * @param followingKey - Vybit following key
+   * @param params - Notification content
+   * @returns Send response with log key
+   * @throws {VybitAPIError} 403 if vybit doesn't allow subscriber-to-owner sends
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sendToOwner('following123abc', {
+   *   message: 'Server is back online',
+   *   linkUrl: 'https://example.com/dashboard'
+   * });
+   * console.log('Notification sent, log key:', result.plk);
+   * ```
+   */
+  async sendToOwner(followingKey, params) {
+    return this.request(`/subscription/following/${followingKey}/send-to-owner`, {
+      method: "POST",
+      body: params ? JSON.stringify(params) : void 0
+    });
+  }
+  /**
+   * Send a notification to all subscribers of a vybit group
+   *
+   * Only available when the vybit's sendPermissions is set to 'subs_group'.
+   * The subscription must be active (status='on') and granted access.
+   *
+   * @param followingKey - Vybit following key
+   * @param params - Notification content
+   * @returns Send response with log key
+   * @throws {VybitAPIError} 403 if vybit doesn't allow subscriber-to-group sends
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sendToGroup('following123abc', {
+   *   message: 'Emergency alert: Check the group chat',
+   *   linkUrl: 'https://example.com/chat'
+   * });
+   * console.log('Notification sent to group, log key:', result.plk);
+   * ```
+   */
+  async sendToGroup(followingKey, params) {
+    return this.request(`/subscription/following/${followingKey}/send-to-group`, {
+      method: "POST",
+      body: params ? JSON.stringify(params) : void 0
+    });
+  }
+  // ==================== Sounds ====================
+  /**
+   * Search for sounds
+   * @param params - Pagination and search parameters
+   * @returns Array of sounds
+   */
+  async searchSounds(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/sounds${query}`);
+  }
+  /**
+   * Get a specific sound by key
+   * @param key - Sound key
+   * @returns Sound details
+   */
+  async getSound(key) {
+    return this.request(`/sound/${key}`);
+  }
+  /**
+   * Get the playback URL for a sound
+   * @param key - Sound key
+   * @returns Full URL to play/download the sound
+   */
+  getSoundPlayUrl(key) {
+    return `${this.baseUrl}/sound/${key}/play`;
+  }
+  // ==================== Logs ====================
+  /**
+   * List all notification logs for the authenticated user
+   * @param params - Pagination and search parameters
+   * @returns Array of logs
+   */
+  async listLogs(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/logs${query}`);
+  }
+  /**
+   * Get a specific log entry by key
+   * @param logKey - Log entry key
+   * @returns Log entry details
+   */
+  async getLog(logKey) {
+    return this.request(`/log/${logKey}`);
+  }
+  /**
+   * List logs for a specific owned vybit
+   * @param vybKey - Vybit key
+   * @param params - Pagination and search parameters
+   * @returns Array of logs for the vybit
+   */
+  async listVybitLogs(vybKey, params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/logs/vybit/${vybKey}${query}`);
+  }
+  /**
+   * List logs for a specific vybit subscription
+   * @param followingKey - Vybit following key
+   * @param params - Pagination and search parameters
+   * @returns Array of logs for the subscription
+   */
+  async listVybitFollowLogs(followingKey, params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/logs/subscription/following/${followingKey}${query}`);
+  }
+  // ==================== Peeps ====================
+  /**
+   * List peeps (access invitations)
+   * @param params - Pagination and search parameters
+   * @returns Array of peeps
+   */
+  async listPeeps(params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/peeps${query}`);
+  }
+  /**
+   * Get a specific peep by key
+   * @param key - Peep key
+   * @returns Peep details
+   */
+  async getPeep(key) {
+    return this.request(`/peep/${key}`);
+  }
+  /**
+   * Create a peep invitation
+   * @param vybitKey - The vybit key to invite the user to
+   * @param email - Email address of the user to invite
+   * @returns Created peep response
+   */
+  async createPeep(vybitKey, email) {
+    return this.request(`/peep/${vybitKey}`, {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  /**
+   * Remove a peep invitation
+   * @param key - Peep key
+   * @returns Delete confirmation
+   */
+  async deletePeep(key) {
+    return this.request(`/peep/${key}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * List peeps for a specific vybit
+   * @param vybitKey - Vybit key
+   * @param params - Pagination and search parameters
+   * @returns Array of peeps for the vybit
+   */
+  async listVybitPeeps(vybitKey, params) {
+    const query = this.buildQueryParams(params);
+    return this.request(`/peeps/${vybitKey}${query}`);
+  }
+}
+apiClient.VybitAPIClient = VybitAPIClient;
+
+var types = {};
+
+Object.defineProperty(types, "__esModule", { value: true });
+
+(function (exports$1) {
+	var __createBinding = this && this.__createBinding || (Object.create ? (function(o, m, k, k2) {
+	  if (k2 === void 0) k2 = k;
+	  var desc = Object.getOwnPropertyDescriptor(m, k);
+	  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	    desc = { enumerable: true, get: function() {
+	      return m[k];
+	    } };
+	  }
+	  Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	  if (k2 === void 0) k2 = k;
+	  o[k2] = m[k];
+	}));
+	var __exportStar = this && this.__exportStar || function(m, exports2) {
+	  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+	};
+	Object.defineProperty(exports$1, "__esModule", { value: true });
+	__exportStar(apiClient, exports$1);
+	__exportStar(types, exports$1); 
+} (dist$1));
+
+class Vybit {
+  constructor() {
+    this.description = {
+      displayName: "Vybit Push Notifications",
+      name: "vybit",
+      icon: "file:vybit.png",
+      group: ["transform"],
+      version: 1,
+      subtitle: '={{$parameter["actionType"]}}',
+      description: "Send notifications with personalized sounds",
+      defaults: {
+        name: "Vybit Push Notifications"
+      },
+      inputs: ["main"],
+      outputs: ["main"],
+      codex: {
+        categories: ["Communication"],
+        subcategories: {
+          Communication: ["Notifications"]
+        },
+        resources: {
+          primaryDocumentation: [
+            {
+              url: "https://developer.vybit.net"
+            }
+          ]
+        }
+      },
+      credentials: [
+        {
+          name: "vybitOAuth2Api",
+          required: true,
+          displayOptions: {
+            show: {
+              authentication: ["oAuth2"]
+            }
+          }
+        },
+        {
+          name: "vybitApi",
+          required: true,
+          displayOptions: {
+            show: {
+              authentication: ["apiKey"]
+            }
+          }
+        }
+      ],
+      properties: [
+        // Authentication selection FIRST
+        {
+          displayName: "Authentication",
+          name: "authentication",
+          type: "options",
+          noDataExpression: true,
+          options: [
+            {
+              name: "OAuth2",
+              value: "oAuth2",
+              description: "Connect your Vybit account (recommended for notifications)"
+            },
+            {
+              name: "API Key",
+              value: "apiKey",
+              description: "Developer API key (advanced features)"
+            }
+          ],
+          default: "oAuth2"
+        },
+        // Action Type for OAuth2 - just notification
+        {
+          displayName: "Action Type",
+          name: "actionType",
+          type: "hidden",
+          displayOptions: {
+            show: {
+              authentication: ["oAuth2"]
+            }
+          },
+          default: "notification"
+        },
+        // Action Type for API Key - all options
+        {
+          displayName: "Resource",
+          name: "actionType",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              authentication: ["apiKey"]
+            }
+          },
+          options: [
+            {
+              name: "Profile",
+              value: "profile",
+              description: "View profile and usage metrics",
+              action: "View profile"
+            },
+            {
+              name: "Vybits",
+              value: "vybits",
+              description: "Manage vybits (custom notifications)",
+              action: "Manage vybits"
+            },
+            {
+              name: "Logs",
+              value: "logs",
+              description: "View notification logs",
+              action: "View logs"
+            },
+            {
+              name: "Sounds",
+              value: "sounds",
+              description: "Search and manage sounds",
+              action: "Manage sounds"
+            },
+            {
+              name: "Peeps",
+              value: "peeps",
+              description: "Manage vybit invitations",
+              action: "Manage peeps"
+            },
+            {
+              name: "Subscriptions",
+              value: "subscriptions",
+              description: "Manage vybit subscriptions",
+              action: "Manage subscriptions"
+            }
+          ],
+          default: "vybits"
+        },
+        // Notification operation (OAuth2) - simplified, just pick vybit
+        {
+          displayName: "Vybit",
+          name: "triggerKey",
+          type: "options",
+          typeOptions: {
+            loadOptionsMethod: "getVybits"
+          },
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["notification"]
+            }
+          },
+          default: "",
+          description: "Select which vybit to trigger"
+        },
+        // ===== PROFILE OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["profile"]
+            }
+          },
+          options: [
+            {
+              name: "Get Profile",
+              value: "getProfile",
+              description: "Get user profile information"
+            },
+            {
+              name: "Get Usage Metrics",
+              value: "getMeter",
+              description: "Get current usage statistics and tier limits"
+            },
+            {
+              name: "Check API Status",
+              value: "getStatus",
+              description: "Check API service health and availability"
+            }
+          ],
+          default: "getProfile"
+        },
+        // ===== VYBITS OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["vybits"]
+            }
+          },
+          options: [
+            {
+              name: "List",
+              value: "list",
+              description: "Get a list of your vybits"
+            },
+            {
+              name: "Get",
+              value: "get",
+              description: "Get details of a specific vybit"
+            },
+            {
+              name: "Create",
+              value: "create",
+              description: "Create a new vybit"
+            },
+            {
+              name: "Update",
+              value: "update",
+              description: "Update an existing vybit"
+            },
+            {
+              name: "Delete",
+              value: "delete",
+              description: "Delete a vybit"
+            },
+            {
+              name: "Trigger",
+              value: "trigger",
+              description: "Trigger a vybit notification"
+            }
+          ],
+          default: "list"
+        },
+        // ===== SUBSCRIPTIONS OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["subscriptions"]
+            }
+          },
+          options: [
+            {
+              name: "List Public Vybits",
+              value: "listPublic",
+              description: "Browse publicly available vybits"
+            },
+            {
+              name: "Get Public Vybit",
+              value: "getPublic",
+              description: "Get details of a public vybit"
+            },
+            {
+              name: "Subscribe",
+              value: "subscribe",
+              description: "Subscribe to a vybit"
+            },
+            {
+              name: "List My Subscriptions",
+              value: "listSubscriptions",
+              description: "Get list of vybits you subscribe to"
+            },
+            {
+              name: "Get Subscription",
+              value: "getSubscription",
+              description: "Get details of a subscription"
+            },
+            {
+              name: "Update Subscription",
+              value: "updateSubscription",
+              description: "Update subscription settings"
+            },
+            {
+              name: "Unsubscribe",
+              value: "unsubscribe",
+              description: "Unsubscribe from a vybit"
+            },
+            {
+              name: "Send to Owner",
+              value: "sendToOwner",
+              description: "Send notification to vybit owner"
+            },
+            {
+              name: "Send to Group",
+              value: "sendToGroup",
+              description: "Send notification to all subscribers"
+            }
+          ],
+          default: "listPublic"
+        },
+        // ===== SOUNDS OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["sounds"]
+            }
+          },
+          options: [
+            {
+              name: "Search",
+              value: "search",
+              description: "Search for sounds"
+            },
+            {
+              name: "Get",
+              value: "get",
+              description: "Get sound details"
+            }
+          ],
+          default: "search"
+        },
+        // ===== LOGS OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["logs"]
+            }
+          },
+          options: [
+            {
+              name: "List All",
+              value: "listAll",
+              description: "List all notification logs"
+            },
+            {
+              name: "Get",
+              value: "get",
+              description: "Get a specific log entry"
+            },
+            {
+              name: "List by Vybit",
+              value: "listByVybit",
+              description: "List logs for a specific vybit"
+            },
+            {
+              name: "List by Subscription",
+              value: "listBySubscription",
+              description: "List logs for a specific subscription"
+            }
+          ],
+          default: "listAll"
+        },
+        // ===== PEEPS OPERATIONS =====
+        {
+          displayName: "Operation",
+          name: "apiOperation",
+          type: "options",
+          noDataExpression: true,
+          displayOptions: {
+            show: {
+              actionType: ["peeps"]
+            }
+          },
+          options: [
+            {
+              name: "List All",
+              value: "listAll",
+              description: "List all peep invitations"
+            },
+            {
+              name: "List by Vybit",
+              value: "listByVybit",
+              description: "List peeps for a specific vybit"
+            },
+            {
+              name: "Invite",
+              value: "create",
+              description: "Invite a user to a vybit"
+            },
+            {
+              name: "Get",
+              value: "get",
+              description: "Get peep details"
+            },
+            {
+              name: "Delete",
+              value: "delete",
+              description: "Remove a peep invitation"
+            }
+          ],
+          default: "listAll"
+        },
+        // ===== COMMON PARAMETER FIELDS =====
+        // Vybit Key (used by vybits, logs, peeps resources)
+        {
+          displayName: "Vybit Key",
+          name: "vybitKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["vybits"],
+              apiOperation: ["get", "trigger", "update", "delete"]
+            }
+          },
+          default: "",
+          description: "The unique key of the vybit"
+        },
+        // Vybit Key for logs
+        {
+          displayName: "Vybit Key",
+          name: "vybitKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["logs"],
+              apiOperation: ["listByVybit"]
+            }
+          },
+          default: "",
+          description: "The unique key of the vybit"
+        },
+        // Vybit Key for peeps
+        {
+          displayName: "Vybit Key",
+          name: "vybitKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["peeps"],
+              apiOperation: ["listByVybit"]
+            }
+          },
+          default: "",
+          description: "The unique key of the vybit"
+        },
+        // Subscription Key
+        {
+          displayName: "Subscription Key",
+          name: "subscriptionKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["subscriptions"],
+              apiOperation: ["getPublic", "subscribe"]
+            }
+          },
+          default: "",
+          description: "The unique key of the subscription"
+        },
+        // Following Key (for subscription management)
+        {
+          displayName: "Following Key",
+          name: "followingKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["subscriptions"],
+              apiOperation: ["getSubscription", "updateSubscription", "unsubscribe", "sendToOwner", "sendToGroup"]
+            }
+          },
+          default: "",
+          description: "The unique key of the subscription following"
+        },
+        // Following Key for logs
+        {
+          displayName: "Following Key",
+          name: "followingKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["logs"],
+              apiOperation: ["listBySubscription"]
+            }
+          },
+          default: "",
+          description: "The unique key of the subscription following"
+        },
+        // Sound Key
+        {
+          displayName: "Sound Key",
+          name: "soundKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["sounds"],
+              apiOperation: ["get"]
+            }
+          },
+          default: "",
+          description: "The unique key of the sound"
+        },
+        // Log Key
+        {
+          displayName: "Log Key",
+          name: "logKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["logs"],
+              apiOperation: ["get"]
+            }
+          },
+          default: "",
+          description: "The unique key of the log entry"
+        },
+        // Peep Key
+        {
+          displayName: "Peep Key",
+          name: "peepKey",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["peeps"],
+              apiOperation: ["get", "delete"]
+            }
+          },
+          default: "",
+          description: "The unique key of the peep"
+        },
+        // ===== LIST/SEARCH OPTIONS =====
+        // Options for vybits list
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          displayOptions: {
+            show: {
+              actionType: ["vybits"],
+              apiOperation: ["list"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Search",
+              name: "search",
+              type: "string",
+              default: "",
+              description: "Search vybits by name"
+            },
+            {
+              displayName: "Limit",
+              name: "limit",
+              type: "number",
+              default: 30,
+              description: "Max number of results to return"
+            },
+            {
+              displayName: "Offset",
+              name: "offset",
+              type: "number",
+              default: 0,
+              description: "Number of results to skip"
+            }
+          ]
+        },
+        // Options for sounds search
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          displayOptions: {
+            show: {
+              actionType: ["sounds"],
+              apiOperation: ["search"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Search",
+              name: "search",
+              type: "string",
+              default: "",
+              description: "Search sounds by name or description"
+            },
+            {
+              displayName: "Limit",
+              name: "limit",
+              type: "number",
+              default: 30,
+              description: "Max number of results to return"
+            },
+            {
+              displayName: "Offset",
+              name: "offset",
+              type: "number",
+              default: 0,
+              description: "Number of results to skip"
+            }
+          ]
+        },
+        // Options for subscriptions list public
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          displayOptions: {
+            show: {
+              actionType: ["subscriptions"],
+              apiOperation: ["listPublic", "listSubscriptions"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Search",
+              name: "search",
+              type: "string",
+              default: "",
+              description: "Search by name"
+            },
+            {
+              displayName: "Limit",
+              name: "limit",
+              type: "number",
+              default: 30,
+              description: "Max number of results to return"
+            },
+            {
+              displayName: "Offset",
+              name: "offset",
+              type: "number",
+              default: 0,
+              description: "Number of results to skip"
+            }
+          ]
+        },
+        // Options for logs list
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          displayOptions: {
+            show: {
+              actionType: ["logs"],
+              apiOperation: ["listAll", "listByVybit", "listBySubscription"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Search",
+              name: "search",
+              type: "string",
+              default: "",
+              description: "Search logs by vybit name or diagnostic fields"
+            },
+            {
+              displayName: "Limit",
+              name: "limit",
+              type: "number",
+              default: 30,
+              description: "Max number of results to return"
+            },
+            {
+              displayName: "Offset",
+              name: "offset",
+              type: "number",
+              default: 0,
+              description: "Number of results to skip"
+            }
+          ]
+        },
+        // Options for peeps list
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          displayOptions: {
+            show: {
+              actionType: ["peeps"],
+              apiOperation: ["listAll", "listByVybit"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Search",
+              name: "search",
+              type: "string",
+              default: "",
+              description: "Search peeps by name"
+            },
+            {
+              displayName: "Limit",
+              name: "limit",
+              type: "number",
+              default: 30,
+              description: "Max number of results to return"
+            },
+            {
+              displayName: "Offset",
+              name: "offset",
+              type: "number",
+              default: 0,
+              description: "Number of results to skip"
+            }
+          ]
+        },
+        // Notification parameters (OAuth2)
+        {
+          displayName: "Additional Fields",
+          name: "additionalFields",
+          type: "collection",
+          placeholder: "Add Field",
+          displayOptions: {
+            show: {
+              actionType: ["notification"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Message",
+              name: "message",
+              type: "string",
+              default: "",
+              description: "Optional message to display with notification"
+            },
+            {
+              displayName: "Image URL",
+              name: "image",
+              type: "string",
+              default: "",
+              description: "Optional image URL to attach to notification"
+            },
+            {
+              displayName: "Link URL",
+              name: "link",
+              type: "string",
+              default: "",
+              description: "Optional redirect URL when notification is tapped"
+            },
+            {
+              displayName: "Log",
+              name: "log",
+              type: "string",
+              default: "",
+              description: "Optional content to append to the vybit log"
+            }
+          ]
+        },
+        // Trigger parameters for Developer API
+        {
+          displayName: "Additional Fields",
+          name: "additionalFields",
+          type: "collection",
+          placeholder: "Add Field",
+          displayOptions: {
+            show: {
+              actionType: ["vybits"],
+              apiOperation: ["trigger"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Message",
+              name: "message",
+              type: "string",
+              default: "",
+              description: "Optional message to display with notification"
+            },
+            {
+              displayName: "Image URL",
+              name: "image",
+              type: "string",
+              default: "",
+              description: "Optional image URL to attach to notification"
+            },
+            {
+              displayName: "Link URL",
+              name: "link",
+              type: "string",
+              default: "",
+              description: "Optional redirect URL when notification is tapped"
+            },
+            {
+              displayName: "Log",
+              name: "log",
+              type: "string",
+              default: "",
+              description: "Optional content to append to the vybit log"
+            }
+          ]
+        },
+        // Create vybit parameters
+        {
+          displayName: "Vybit Name",
+          name: "vybitName",
+          type: "string",
+          required: true,
+          displayOptions: {
+            show: {
+              actionType: ["vybits"],
+              apiOperation: ["create"]
+            }
+          },
+          default: "",
+          description: "The name of the vybit to create"
+        },
+        // Update vybit parameters
+        {
+          displayName: "Update Fields",
+          name: "updateFields",
+          type: "collection",
+          placeholder: "Add Field",
+          displayOptions: {
+            show: {
+              actionType: ["vybits"],
+              apiOperation: ["update"]
+            }
+          },
+          default: {},
+          options: [
+            {
+              displayName: "Name",
+              name: "name",
+              type: "string",
+              default: "",
+              description: "Vybit display name (max 255 characters)"
+            },
+            {
+              displayName: "Description",
+              name: "description",
+              type: "string",
+              default: "",
+              description: "Detailed vybit description"
+            },
+            {
+              displayName: "Sound Key",
+              name: "soundKey",
+              type: "string",
+              default: "",
+              description: "Key of the sound to play (must be an available sound)"
+            },
+            {
+              displayName: "Trigger Type",
+              name: "triggerType",
+              type: "options",
+              options: [
+                { name: "Webhook", value: "webhook" },
+                { name: "Schedule", value: "schedule" },
+                { name: "Geofence", value: "geofence" },
+                { name: "Integration", value: "integration" }
+              ],
+              default: "webhook",
+              description: "How this vybit is triggered"
+            },
+            {
+              displayName: "Access",
+              name: "access",
+              type: "options",
+              options: [
+                { name: "Public", value: "public" },
+                { name: "Private", value: "private" },
+                { name: "Unlisted", value: "unlisted" }
+              ],
+              default: "private",
+              description: "Vybit visibility and access control"
+            },
+            {
+              displayName: "Status",
+              name: "status",
+              type: "options",
+              options: [
+                { name: "On", value: "on" },
+                { name: "Off", value: "off" }
+              ],
+              default: "on",
+              description: "Enable or disable the vybit"
+            },
+            {
+              displayName: "Message",
+              name: "message",
+              type: "string",
+              default: "",
+              description: "Default message displayed with notifications (max 500 characters)"
+            },
+            {
+              displayName: "Image URL",
+              name: "imageUrl",
+              type: "string",
+              default: "",
+              description: "Default image URL for notifications"
+            },
+            {
+              displayName: "Link URL",
+              name: "linkUrl",
+              type: "string",
+              default: "",
+              description: "Default URL to open when notification is tapped"
+            },
+            {
+              displayName: "Send Permissions",
+              name: "sendPermissions",
+              type: "options",
+              options: [
+                { name: "Owner \u2192 Subscribers (one-way)", value: "owner_subs" },
+                { name: "Owner \u2194 Subscribers (two-way)", value: "subs_owner" },
+                { name: "Subscribers \u2192 Group (group broadcast)", value: "subs_group" }
+              ],
+              default: "owner_subs",
+              description: "Who can trigger and receive notifications"
+            }
+          ]
+        }
+      ]
+    };
+    this.methods = {
+      loadOptions: {
+        async getVybits() {
+          try {
+            let credentials;
+            try {
+              credentials = await this.getCredentials("vybitOAuth2Api");
+            } catch (error) {
+              this.logger.info("No credentials selected", { error: error.message });
+              return [{
+                name: "Please connect your Vybit account first",
+                value: "",
+                description: "Click above to create or select a credential"
+              }];
+            }
+            const oauthData = credentials?.oauthTokenData;
+            const accessToken = oauthData?.access_token;
+            this.logger.info("OAuth token data", {
+              hasOauthData: !!oauthData,
+              hasAccessToken: !!accessToken,
+              tokenLength: accessToken?.length
+            });
+            if (!accessToken) {
+              this.logger.warn("No access token in credentials", {
+                credentialKeys: credentials ? Object.keys(credentials) : [],
+                oauthDataKeys: oauthData ? Object.keys(oauthData) : []
+              });
+              return [{
+                name: "Please complete OAuth connection",
+                value: "",
+                description: 'Click "Connect my account" to authorize'
+              }];
+            }
+            this.logger.info("Loading vybits...", {
+              url: "https://vybit.net/rest/vybit_list",
+              hasToken: !!accessToken,
+              tokenLength: accessToken?.length
+            });
+            const response = await this.helpers.httpRequest({
+              method: "GET",
+              url: "https://vybit.net/rest/vybit_list",
+              headers: {
+                "Authorization": `Bearer ${accessToken}`,
+                "Content-Type": "application/json"
+              },
+              json: true,
+              returnFullResponse: false
+            });
+            this.logger.info("Vybit API response received", {
+              isArray: Array.isArray(response),
+              type: typeof response,
+              keys: response ? Object.keys(response).slice(0, 5) : [],
+              length: Array.isArray(response) ? response.length : "N/A"
+            });
+            const vybits = Array.isArray(response) ? response : response.vybits || response.data || [];
+            this.logger.info("Processed vybits", {
+              count: vybits.length,
+              firstVybit: vybits[0] ? {
+                name: vybits[0].name,
+                hasTriggerKey: !!vybits[0].triggerKey,
+                keys: Object.keys(vybits[0])
+              } : null
+            });
+            if (!Array.isArray(vybits) || vybits.length === 0) {
+              return [{
+                name: "No vybits found",
+                value: "__no_vybits__",
+                description: "Create a vybit at vybit.net first"
+              }];
+            }
+            return vybits.filter((vybit) => {
+              const key = vybit.triggerKey || vybit.trigger_key || vybit.key;
+              return key && key.length > 0;
+            }).map((vybit) => ({
+              name: vybit.name || vybit.title || "Unnamed Vybit",
+              value: vybit.triggerKey || vybit.trigger_key || vybit.key,
+              description: vybit.description || void 0
+            }));
+          } catch (error) {
+            this.logger.error("Error in getVybits", {
+              message: error.message,
+              stack: error.stack,
+              name: error.name
+            });
+            if (error.message?.includes("401")) {
+              return [{
+                name: "Authorization failed - please reconnect",
+                value: "",
+                description: "Your token may have expired"
+              }];
+            }
+            throw new Error(`Failed to load vybits: ${error.message}`);
+          }
+        }
+      }
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const returnData = [];
+    const actionType = this.getNodeParameter("actionType", 0);
+    let client;
+    if (actionType !== "notification") {
+      const credentials = await this.getCredentials("vybitApi");
+      client = new dist$1.VybitAPIClient({
+        apiKey: credentials.apiKey,
+        baseURL: credentials.baseUrl
+      });
+    }
+    for (let i = 0; i < items.length; i++) {
+      try {
+        if (actionType === "notification") {
+          const credentials = await this.getCredentials("vybitOAuth2Api");
+          const oauthData = credentials?.oauthTokenData;
+          const accessToken = oauthData?.access_token;
+          const triggerKey = this.getNodeParameter("triggerKey", i);
+          const additionalFields = this.getNodeParameter("additionalFields", i, {});
+          const body = {};
+          if (additionalFields.message) body.message = additionalFields.message;
+          if (additionalFields.image) body.imageUrl = additionalFields.image;
+          if (additionalFields.link) body.linkUrl = additionalFields.link;
+          if (additionalFields.log !== void 0) body.log = additionalFields.log;
+          const result = await this.helpers.httpRequest({
+            method: "POST",
+            url: `https://vybit.net/fire/${triggerKey}`,
+            headers: {
+              "Authorization": `Bearer ${accessToken}`,
+              "Content-Type": "application/json"
+            },
+            body,
+            json: true
+          });
+          returnData.push({ json: result });
+        } else if (actionType === "profile") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "getProfile") {
+            const profile = await client.getProfile();
+            returnData.push({ json: profile });
+          } else if (apiOperation === "getMeter") {
+            const meter = await client.getMeter();
+            returnData.push({ json: meter });
+          } else if (apiOperation === "getStatus") {
+            const status = await client.getStatus();
+            returnData.push({ json: status });
+          }
+        } else if (actionType === "vybits") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "list") {
+            const options = this.getNodeParameter("options", i, {});
+            const vybits = await client.listVybits({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: vybits });
+          } else if (apiOperation === "get") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            const vybit = await client.getVybit(vybitKey);
+            returnData.push({ json: vybit });
+          } else if (apiOperation === "create") {
+            const name = this.getNodeParameter("vybitName", i);
+            const vybit = await client.createVybit({ name });
+            returnData.push({ json: vybit });
+          } else if (apiOperation === "update") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            const updateFields = this.getNodeParameter("updateFields", i, {});
+            const vybit = await client.updateVybit(vybitKey, updateFields);
+            returnData.push({ json: vybit });
+          } else if (apiOperation === "delete") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            await client.deleteVybit(vybitKey);
+            returnData.push({ json: { success: true, vybitKey } });
+          } else if (apiOperation === "trigger") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            const additionalFields = this.getNodeParameter("additionalFields", i, {});
+            const result = await client.triggerVybit(vybitKey, {
+              message: additionalFields.message,
+              image: additionalFields.image,
+              link: additionalFields.link,
+              log: additionalFields.log
+            });
+            returnData.push({ json: result });
+          }
+        } else if (actionType === "subscriptions") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "listPublic") {
+            const options = this.getNodeParameter("options", i, {});
+            const vybits = await client.listPublicSubscriptions({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: vybits });
+          } else if (apiOperation === "getPublic") {
+            const subscriptionKey = this.getNodeParameter("subscriptionKey", i);
+            const vybit = await client.getPublicSubscription(subscriptionKey);
+            returnData.push({ json: vybit });
+          } else if (apiOperation === "subscribe") {
+            const subscriptionKey = this.getNodeParameter("subscriptionKey", i);
+            const result = await client.subscribe(subscriptionKey);
+            returnData.push({ json: result });
+          } else if (apiOperation === "listSubscriptions") {
+            const options = this.getNodeParameter("options", i, {});
+            const subscriptions = await client.listSubscriptions({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: subscriptions });
+          } else if (apiOperation === "getSubscription") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            const subscription = await client.getSubscription(followingKey);
+            returnData.push({ json: subscription });
+          } else if (apiOperation === "updateSubscription") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            const updateFields = this.getNodeParameter("updateFields", i, {});
+            const subscription = await client.updateSubscription(followingKey, updateFields);
+            returnData.push({ json: subscription });
+          } else if (apiOperation === "unsubscribe") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            await client.unsubscribe(followingKey);
+            returnData.push({ json: { success: true, followingKey } });
+          } else if (apiOperation === "sendToOwner") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            const additionalFields = this.getNodeParameter("additionalFields", i, {});
+            const result = await client.sendToOwner(followingKey, {
+              message: additionalFields.message
+            });
+            returnData.push({ json: result });
+          } else if (apiOperation === "sendToGroup") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            const additionalFields = this.getNodeParameter("additionalFields", i, {});
+            const result = await client.sendToGroup(followingKey, {
+              message: additionalFields.message
+            });
+            returnData.push({ json: result });
+          }
+        } else if (actionType === "sounds") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "search") {
+            const options = this.getNodeParameter("options", i, {});
+            const sounds = await client.searchSounds({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: sounds });
+          } else if (apiOperation === "get") {
+            const soundKey = this.getNodeParameter("soundKey", i);
+            const sound = await client.getSound(soundKey);
+            returnData.push({ json: sound });
+          }
+        } else if (actionType === "logs") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "listAll") {
+            const options = this.getNodeParameter("options", i, {});
+            const logs = await client.listLogs({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: logs });
+          } else if (apiOperation === "get") {
+            const logKey = this.getNodeParameter("logKey", i);
+            const log = await client.getLog(logKey);
+            returnData.push({ json: log });
+          } else if (apiOperation === "listByVybit") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            const options = this.getNodeParameter("options", i, {});
+            const logs = await client.listLogsByVybit(vybitKey, {
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: logs });
+          } else if (apiOperation === "listBySubscription") {
+            const followingKey = this.getNodeParameter("followingKey", i);
+            const options = this.getNodeParameter("options", i, {});
+            const logs = await client.listLogsBySubscription(followingKey, {
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: logs });
+          }
+        } else if (actionType === "peeps") {
+          const apiOperation = this.getNodeParameter("apiOperation", i);
+          if (apiOperation === "listAll") {
+            const options = this.getNodeParameter("options", i, {});
+            const peeps = await client.listPeeps({
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: peeps });
+          } else if (apiOperation === "listByVybit") {
+            const vybitKey = this.getNodeParameter("vybitKey", i);
+            const options = this.getNodeParameter("options", i, {});
+            const peeps = await client.listPeepsByVybit(vybitKey, {
+              search: options.search,
+              limit: options.limit,
+              offset: options.offset
+            });
+            returnData.push({ json: peeps });
+          } else if (apiOperation === "create") {
+            const peepKey = this.getNodeParameter("peepKey", i);
+            const result = await client.createPeep(peepKey);
+            returnData.push({ json: result });
+          } else if (apiOperation === "get") {
+            const peepKey = this.getNodeParameter("peepKey", i);
+            const peep = await client.getPeep(peepKey);
+            returnData.push({ json: peep });
+          } else if (apiOperation === "delete") {
+            const peepKey = this.getNodeParameter("peepKey", i);
+            await client.deletePeep(peepKey);
+            returnData.push({ json: { success: true, peepKey } });
+          }
+        }
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({ json: { error: error.message } });
+          continue;
+        }
+        throw error;
+      }
+    }
+    return [returnData];
+  }
+}
+
+export { Vybit };