@symbo.ls/sdk 2.34.4 → 2.34.7

package/dist/esm/index.js

@@ -47021,7 +47021,7 @@ var PaymentService = class extends BaseService {
         status: status.status
       };
     } catch (error) {
-      throw new Error(`Failed to get subscription details: ${error.message}`);
+      throw new Error(`Failed to get subscription details: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -47657,7 +47657,7 @@ var BranchService = class extends BaseService {
       throw new Error(response.message);
     } catch (error) {
       if (error.message.includes("conflicts") || error.message.includes("409")) {
-        throw new Error(`Merge conflicts detected: ${error.message}`);
+        throw new Error(`Merge conflicts detected: ${error.message}`, { cause: error });
       }
       throw new Error(`Failed to merge branch: ${error.message}`, { cause: error });
     }
@@ -47870,7 +47870,7 @@ var BranchService = class extends BaseService {
       );
       return branchStatuses;
     } catch (error) {
-      throw new Error(`Failed to get branches with status: ${error.message}`);
+      throw new Error(`Failed to get branches with status: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -47901,7 +47901,7 @@ var BranchService = class extends BaseService {
         error: 'Cannot use "main" as a branch name'
       };
     }
-    if (!/^[a-zA-Z0-9-_]+$/.test(branchName)) {
+    if (!/^[a-zA-Z0-9-_]+$/u.test(branchName)) {
       return {
         isValid: false,
         error: "Branch name can only contain letters, numbers, hyphens, and underscores"
@@ -47919,7 +47919,7 @@ var BranchService = class extends BaseService {
     if (!branchName) {
       return "";
     }
-    return branchName.trim().toLowerCase().replace(/[^a-z0-9-_]/gu, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return branchName.trim().toLowerCase().replace(/[^a-z0-9-_]/gu, "-").replace(/-+/gu, "-").replace(/^-|-$/gu, "");
   }
 };
 
@@ -48107,7 +48107,7 @@ var PullRequestService = class extends BaseService {
       throw new Error(response.message);
     } catch (error) {
       if (error.message.includes("conflicts") || error.message.includes("409")) {
-        throw new Error(`Pull request has merge conflicts: ${error.message}`);
+        throw new Error(`Pull request has merge conflicts: ${error.message}`, { cause: error });
       }
       throw new Error(`Failed to merge pull request: ${error.message}`, { cause: error });
     }
@@ -48224,7 +48224,8 @@ var PullRequestService = class extends BaseService {
       return ((_a2 = prData == null ? void 0 : prData.data) == null ? void 0 : _a2.canMerge) || false;
     } catch (error) {
       throw new Error(
-        `Failed to check pull request mergeability: ${error.message}`
+        `Failed to check pull request mergeability: ${error.message}`,
+        { cause: error }
       );
     }
   }
@@ -48250,7 +48251,8 @@ var PullRequestService = class extends BaseService {
       };
     } catch (error) {
       throw new Error(
-        `Failed to get pull request status summary: ${error.message}`
+        `Failed to get pull request status summary: ${error.message}`,
+        { cause: error }
       );
     }
   }
@@ -48344,7 +48346,7 @@ var PullRequestService = class extends BaseService {
       });
       return stats;
     } catch (error) {
-      throw new Error(`Failed to get pull request stats: ${error.message}`);
+      throw new Error(`Failed to get pull request stats: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -48371,7 +48373,7 @@ var PullRequestService = class extends BaseService {
       }
       throw new Error(response.message);
     } catch (error) {
-      throw new Error(`Failed to close pull request: ${error.message}`);
+      throw new Error(`Failed to close pull request: ${error.message}`, { cause: error });
     }
   }
   /**
@@ -48398,7 +48400,7 @@ var PullRequestService = class extends BaseService {
       }
       throw new Error(response.message);
     } catch (error) {
-      throw new Error(`Failed to reopen pull request: ${error.message}`);
+      throw new Error(`Failed to reopen pull request: ${error.message}`, { cause: error });
     }
   }
 };
@@ -49644,6 +49646,691 @@ var TrackingService = class extends BaseService {
   }
 };
 
+// src/services/WaitlistService.js
+var WaitlistService = class extends BaseService {
+  // ==================== WAITLIST METHODS ====================
+  /**
+   * Join a waitlist campaign (public).
+   *
+   * Mirrors: POST /waitlist (WaitlistController.join)
+   */
+  async joinWaitlist(data2 = {}) {
+    this._requireReady("joinWaitlist");
+    if (!data2 || typeof data2 !== "object") {
+      throw new Error("Waitlist join payload is required");
+    }
+    if (!data2.email) {
+      throw new Error("Email is required");
+    }
+    try {
+      const response = await this._request("/waitlist", {
+        method: "POST",
+        body: JSON.stringify(data2),
+        methodName: "joinWaitlist"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to join waitlist: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List waitlist entries (admin).
+   *
+   * Mirrors: GET /waitlist (WaitlistController.list)
+   */
+  async listWaitlistEntries(options = {}) {
+    this._requireReady("listWaitlistEntries");
+    const {
+      campaignKey,
+      status,
+      search,
+      page,
+      limit
+    } = options || {};
+    const queryParams = new URLSearchParams();
+    if (campaignKey != null) {
+      queryParams.append("campaignKey", String(campaignKey));
+    }
+    if (status != null) {
+      queryParams.append("status", String(status));
+    }
+    if (search != null) {
+      queryParams.append("search", String(search));
+    }
+    if (page != null) {
+      queryParams.append("page", String(page));
+    }
+    if (limit != null) {
+      queryParams.append("limit", String(limit));
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/waitlist${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "listWaitlistEntries"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list waitlist entries: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update a waitlist entry (admin).
+   *
+   * Mirrors: PATCH /waitlist/:id (WaitlistController.update)
+   */
+  async updateWaitlistEntry(id2, update = {}) {
+    this._requireReady("updateWaitlistEntry");
+    if (!id2) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id2}`, {
+        method: "PATCH",
+        body: JSON.stringify(update),
+        methodName: "updateWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Send an invitation email for a waitlist entry (admin).
+   *
+   * Mirrors: POST /waitlist/:id/invite (WaitlistController.invite)
+   */
+  async inviteWaitlistEntry(id2) {
+    this._requireReady("inviteWaitlistEntry");
+    if (!id2) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id2}/invite`, {
+        method: "POST",
+        methodName: "inviteWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to invite waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+};
+
+// src/services/MetricsService.js
+var MetricsService = class extends BaseService {
+  // ==================== METRICS METHODS ====================
+  /**
+   * Contribution heat-map stats.
+   *
+   * Mirrors: GET /metrics/contributions (MetricsController.getContributions)
+   */
+  async getContributions(options = {}) {
+    this._requireReady("getContributions");
+    const { projectId, userId, from: from2, to } = options || {};
+    const queryParams = new URLSearchParams();
+    if (projectId != null) {
+      queryParams.append("projectId", String(projectId));
+    }
+    if (userId != null) {
+      queryParams.append("userId", String(userId));
+    }
+    if (from2 != null) {
+      queryParams.append("from", String(from2));
+    }
+    if (to != null) {
+      queryParams.append("to", String(to));
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/metrics/contributions${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "getContributions"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get contribution stats: ${error.message}`, { cause: error });
+    }
+  }
+};
+
+// src/services/IntegrationService.js
+var IntegrationService = class extends BaseService {
+  // ==================== INTEGRATION METHODS ====================
+  /**
+   * Programmatic auth sanity check (API key based).
+   *
+   * Mirrors: GET /integrations/whoami (requireApiKey)
+   *
+   * Assumption: backend reads API key from `x-api-key` header.
+   * You can override via `options.headers`.
+   */
+  async integrationWhoami(apiKey, options = {}) {
+    this._requireReady("integrationWhoami");
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    const headers = {
+      "x-api-key": apiKey,
+      ...options.headers || {}
+    };
+    try {
+      const response = await this._request("/integrations/whoami", {
+        method: "GET",
+        headers,
+        methodName: "integrationWhoami"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to validate integration API key: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List integrations visible to the user.
+   *
+   * Mirrors: GET /integrations?orgId=&projectId=
+   */
+  async listIntegrations(options = {}) {
+    this._requireReady("listIntegrations");
+    const { orgId, projectId } = options || {};
+    const queryParams = new URLSearchParams();
+    if (orgId != null) {
+      queryParams.append("orgId", String(orgId));
+    }
+    if (projectId != null) {
+      queryParams.append("projectId", String(projectId));
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/integrations${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "listIntegrations"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list integrations: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Create an integration.
+   *
+   * Mirrors: POST /integrations
+   */
+  async createIntegration(data2 = {}) {
+    this._requireReady("createIntegration");
+    if (!data2 || typeof data2 !== "object") {
+      throw new Error("Integration payload is required");
+    }
+    if (!data2.name) {
+      throw new Error("Integration name is required");
+    }
+    if (!data2.ownerType) {
+      throw new Error("ownerType is required");
+    }
+    try {
+      const response = await this._request("/integrations", {
+        method: "POST",
+        body: JSON.stringify(data2),
+        methodName: "createIntegration"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create integration: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update an integration.
+   *
+   * Mirrors: PATCH /integrations/:integrationId
+   */
+  async updateIntegration(integrationId, update = {}) {
+    this._requireReady("updateIntegration");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}`, {
+        method: "PATCH",
+        body: JSON.stringify(update),
+        methodName: "updateIntegration"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update integration: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== INTEGRATION API KEY METHODS ====================
+  /**
+   * Create a new API key for an integration.
+   *
+   * Mirrors: POST /integrations/:integrationId/api-keys
+   */
+  async createIntegrationApiKey(integrationId, data2 = {}) {
+    this._requireReady("createIntegrationApiKey");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!data2 || typeof data2 !== "object") {
+      throw new Error("API key payload is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/api-keys`, {
+        method: "POST",
+        body: JSON.stringify(data2),
+        methodName: "createIntegrationApiKey"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create integration API key: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List API keys for an integration.
+   *
+   * Mirrors: GET /integrations/:integrationId/api-keys
+   */
+  async listIntegrationApiKeys(integrationId) {
+    this._requireReady("listIntegrationApiKeys");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/api-keys`, {
+        method: "GET",
+        methodName: "listIntegrationApiKeys"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list integration API keys: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Revoke an API key for an integration.
+   *
+   * Mirrors: POST /integrations/:integrationId/api-keys/:keyId/revoke
+   */
+  async revokeIntegrationApiKey(integrationId, keyId) {
+    this._requireReady("revokeIntegrationApiKey");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!keyId) {
+      throw new Error("API key ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/api-keys/${keyId}/revoke`,
+        {
+          method: "POST",
+          methodName: "revokeIntegrationApiKey"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to revoke integration API key: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== WEBHOOK METHODS ====================
+  /**
+   * Create a webhook endpoint for an integration.
+   *
+   * Mirrors: POST /integrations/:integrationId/webhooks
+   */
+  async createIntegrationWebhook(integrationId, data2 = {}) {
+    this._requireReady("createIntegrationWebhook");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!data2 || typeof data2 !== "object") {
+      throw new Error("Webhook payload is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/webhooks`, {
+        method: "POST",
+        body: JSON.stringify(data2),
+        methodName: "createIntegrationWebhook"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create integration webhook: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List webhook endpoints for an integration.
+   *
+   * Mirrors: GET /integrations/:integrationId/webhooks
+   */
+  async listIntegrationWebhooks(integrationId) {
+    this._requireReady("listIntegrationWebhooks");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/webhooks`, {
+        method: "GET",
+        methodName: "listIntegrationWebhooks"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list integration webhooks: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update a webhook endpoint for an integration.
+   *
+   * Mirrors: PATCH /integrations/:integrationId/webhooks/:webhookId
+   */
+  async updateIntegrationWebhook(integrationId, webhookId, update = {}) {
+    this._requireReady("updateIntegrationWebhook");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!webhookId) {
+      throw new Error("Webhook ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/webhooks/${webhookId}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(update),
+          methodName: "updateIntegrationWebhook"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update integration webhook: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Delete a webhook endpoint for an integration.
+   *
+   * Mirrors: DELETE /integrations/:integrationId/webhooks/:webhookId
+   */
+  async deleteIntegrationWebhook(integrationId, webhookId) {
+    this._requireReady("deleteIntegrationWebhook");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!webhookId) {
+      throw new Error("Webhook ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/webhooks/${webhookId}`,
+        {
+          method: "DELETE",
+          methodName: "deleteIntegrationWebhook"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      if (response == null) {
+        return null;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to delete integration webhook: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List webhook deliveries for an integration webhook.
+   *
+   * Mirrors: GET /integrations/:integrationId/webhooks/:webhookId/deliveries
+   */
+  async listIntegrationWebhookDeliveries(integrationId, webhookId, options = {}) {
+    this._requireReady("listIntegrationWebhookDeliveries");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!webhookId) {
+      throw new Error("Webhook ID is required");
+    }
+    const { page, limit, status, includePayload } = options || {};
+    const queryParams = new URLSearchParams();
+    if (page != null) {
+      queryParams.append("page", String(page));
+    }
+    if (limit != null) {
+      queryParams.append("limit", String(limit));
+    }
+    if (status != null) {
+      queryParams.append("status", String(status));
+    }
+    if (includePayload != null) {
+      queryParams.append("includePayload", String(includePayload));
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/integrations/${integrationId}/webhooks/${webhookId}/deliveries${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "listIntegrationWebhookDeliveries"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list webhook deliveries: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Replay a webhook delivery.
+   *
+   * Mirrors: POST /integrations/:integrationId/webhooks/:webhookId/replay
+   * Body: { deliveryId }
+   */
+  async replayIntegrationWebhookDelivery(integrationId, webhookId, deliveryId) {
+    this._requireReady("replayIntegrationWebhookDelivery");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!webhookId) {
+      throw new Error("Webhook ID is required");
+    }
+    if (!deliveryId) {
+      throw new Error("deliveryId is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/webhooks/${webhookId}/replay`,
+        {
+          method: "POST",
+          body: JSON.stringify({ deliveryId }),
+          methodName: "replayIntegrationWebhookDelivery"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to replay webhook delivery: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== CONNECTOR METHODS (GITHUB) ====================
+  /**
+   * List GitHub connectors for an integration.
+   *
+   * Mirrors: GET /integrations/:integrationId/connectors/github
+   */
+  async listGitHubConnectors(integrationId) {
+    this._requireReady("listGitHubConnectors");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/connectors/github`, {
+        method: "GET",
+        methodName: "listGitHubConnectors"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list GitHub connectors: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Create a GitHub connector for an integration.
+   *
+   * Mirrors: POST /integrations/:integrationId/connectors/github
+   */
+  async createGitHubConnector(integrationId, data2 = {}) {
+    this._requireReady("createGitHubConnector");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!data2 || typeof data2 !== "object") {
+      throw new Error("Connector payload is required");
+    }
+    if (!data2.projectId) {
+      throw new Error("projectId is required");
+    }
+    if (!data2.repository) {
+      throw new Error("repository is required");
+    }
+    try {
+      const response = await this._request(`/integrations/${integrationId}/connectors/github`, {
+        method: "POST",
+        body: JSON.stringify(data2),
+        methodName: "createGitHubConnector"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create GitHub connector: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update a GitHub connector.
+   *
+   * Mirrors: PATCH /integrations/:integrationId/connectors/github/:connectorId
+   */
+  async updateGitHubConnector(integrationId, connectorId, update = {}) {
+    this._requireReady("updateGitHubConnector");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!connectorId) {
+      throw new Error("Connector ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/connectors/github/${connectorId}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(update),
+          methodName: "updateGitHubConnector"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update GitHub connector: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Delete a GitHub connector.
+   *
+   * Mirrors: DELETE /integrations/:integrationId/connectors/github/:connectorId
+   */
+  async deleteGitHubConnector(integrationId, connectorId) {
+    this._requireReady("deleteGitHubConnector");
+    if (!integrationId) {
+      throw new Error("Integration ID is required");
+    }
+    if (!connectorId) {
+      throw new Error("Connector ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/integrations/${integrationId}/connectors/github/${connectorId}`,
+        {
+          method: "DELETE",
+          methodName: "deleteGitHubConnector"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      if (response == null) {
+        return null;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to delete GitHub connector: ${error.message}`, { cause: error });
+    }
+  }
+};
+
 // src/services/index.js
 var createService = (ServiceClass, config) => new ServiceClass(config);
 var createAuthService = (config) => createService(AuthService, config);
@@ -49659,6 +50346,9 @@ var createPullRequestService = (config) => createService(PullRequestService, con
 var createAdminService = (config) => createService(AdminService, config);
 var createScreenshotService = (config) => createService(ScreenshotService, config);
 var createTrackingService = (config) => createService(TrackingService, config);
+var createWaitlistService = (config) => createService(WaitlistService, config);
+var createMetricsService = (config) => createService(MetricsService, config);
+var createIntegrationService = (config) => createService(IntegrationService, config);
 
 // src/utils/services.js
 var SERVICE_METHODS = {
@@ -49935,7 +50625,32 @@ var SERVICE_METHODS = {
   flushQueue: "tracking",
   getClient: "tracking",
   isEnabled: "tracking",
-  isInitialized: "tracking"
+  isInitialized: "tracking",
+  // Waitlist methods
+  joinWaitlist: "waitlist",
+  listWaitlistEntries: "waitlist",
+  updateWaitlistEntry: "waitlist",
+  inviteWaitlistEntry: "waitlist",
+  // Metrics methods
+  getContributions: "metrics",
+  // Integration methods
+  integrationWhoami: "integration",
+  listIntegrations: "integration",
+  createIntegration: "integration",
+  updateIntegration: "integration",
+  createIntegrationApiKey: "integration",
+  listIntegrationApiKeys: "integration",
+  revokeIntegrationApiKey: "integration",
+  createIntegrationWebhook: "integration",
+  listIntegrationWebhooks: "integration",
+  updateIntegrationWebhook: "integration",
+  deleteIntegrationWebhook: "integration",
+  listIntegrationWebhookDeliveries: "integration",
+  replayIntegrationWebhookDelivery: "integration",
+  listGitHubConnectors: "integration",
+  createGitHubConnector: "integration",
+  updateGitHubConnector: "integration",
+  deleteGitHubConnector: "integration"
 };
 
 // src/index.js
@@ -50054,6 +50769,27 @@ var SDK = class {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        "waitlist",
+        createWaitlistService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "metrics",
+        createMetricsService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "integration",
+        createIntegrationService({
+          context: this._context,
+          options: this._options
+        })
       )
     ]);
     return this;
@@ -50178,12 +50914,15 @@ export {
   createCollabService,
   createDnsService,
   createFileService,
+  createIntegrationService,
+  createMetricsService,
   createPaymentService,
   createPlanService,
   createProjectService,
   createPullRequestService,
   createSubscriptionService,
   createTrackingService,
+  createWaitlistService,
   index_default as default,
   environment_default as environment,
   isLocalhost