@nvisy/sdk 0.3.0 → 0.4.0

package/dist/services/index.js

@@ -1,1067 +1,3 @@
-// src/services/account.ts
-var Account = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * Get the authenticated user's account details
-   * @returns Promise that resolves with the account details
-   * @throws {ApiError} if the request fails
-   */
-  async getAccount() {
-    const { data } = await this.#api.GET("/account");
-    return data;
-  }
-  /**
-   * Update the authenticated user's account details
-   * @param updates - Account update request
-   * @returns Promise that resolves with the updated account
-   * @throws {ApiError} if the request fails
-   */
-  async updateAccount(updates) {
-    const { data } = await this.#api.PATCH("/account", {
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete the authenticated user's account
-   * @returns Promise that resolves when the account is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteAccount() {
-    await this.#api.DELETE("/account");
-  }
-};
+import { a as Policies, c as Members, d as Contexts, f as Connections, g as Account, h as Activities, i as Runs, l as Invites, m as ApiTokens, n as Webhooks, o as Pipelines, p as Auth, r as Status, s as Notifications, t as Workspaces, u as Files } from "../services-Dh0FMDzU.js";
 
-// src/services/activities.ts
-var Activities = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List activities for a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of activities
-   * @throws {ApiError} if the request fails
-   */
-  async listActivities(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/activities/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-};
-
-// src/services/annotations.ts
-var Annotations = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List annotations for a file
-   * @param fileId - File ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of annotations
-   * @throws {ApiError} if the request fails
-   */
-  async listAnnotations(fileId, query) {
-    const { data } = await this.#api.GET("/files/{fileId}/annotations/", {
-      params: { path: { fileId }, query }
-    });
-    return data;
-  }
-  /**
-   * Get annotation details by ID
-   * @param annotationId - Annotation ID
-   * @returns Promise that resolves with the annotation details
-   * @throws {ApiError} if the request fails
-   */
-  async getAnnotation(annotationId) {
-    const { data } = await this.#api.GET("/annotations/{annotationId}", {
-      params: { path: { annotationId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new annotation
-   * @param fileId - File ID
-   * @param annotation - Annotation creation request
-   * @returns Promise that resolves with the created annotation
-   * @throws {ApiError} if the request fails
-   */
-  async createAnnotation(fileId, annotation) {
-    const { data } = await this.#api.POST("/files/{fileId}/annotations/", {
-      params: { path: { fileId } },
-      body: annotation
-    });
-    return data;
-  }
-  /**
-   * Update an existing annotation
-   * @param annotationId - Annotation ID
-   * @param updates - Annotation update request
-   * @returns Promise that resolves with the updated annotation
-   * @throws {ApiError} if the request fails
-   */
-  async updateAnnotation(annotationId, updates) {
-    const { data } = await this.#api.PATCH("/annotations/{annotationId}", {
-      params: { path: { annotationId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete an annotation
-   * @param annotationId - Annotation ID
-   * @returns Promise that resolves when the annotation is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteAnnotation(annotationId) {
-    await this.#api.DELETE("/annotations/{annotationId}", {
-      params: { path: { annotationId } }
-    });
-  }
-};
-
-// src/services/api-tokens.ts
-var ApiTokens = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all API tokens for the authenticated account
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of API tokens
-   * @throws {ApiError} if the request fails
-   */
-  async listApiTokens(query) {
-    const { data } = await this.#api.GET("/api-tokens/", {
-      params: { query }
-    });
-    return data;
-  }
-  /**
-   * Get a specific API token by token ID
-   * @param tokenId - The token identifier
-   * @returns Promise that resolves with the API token details
-   * @throws {ApiError} if the request fails
-   */
-  async getApiToken(tokenId) {
-    const { data } = await this.#api.GET("/api-tokens/{tokenId}/", {
-      params: { path: { tokenId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new API token
-   * @param token - Token creation request
-   * @returns Promise that resolves with the created token (includes JWT, shown only once)
-   * @throws {ApiError} if the request fails
-   */
-  async createApiToken(token) {
-    const { data } = await this.#api.POST("/api-tokens/", {
-      body: token
-    });
-    return data;
-  }
-  /**
-   * Update an existing API token
-   * @param tokenId - The token identifier
-   * @param updates - Token update request
-   * @returns Promise that resolves with the updated token
-   * @throws {ApiError} if the request fails
-   */
-  async updateApiToken(tokenId, updates) {
-    const { data } = await this.#api.PATCH("/api-tokens/{tokenId}/", {
-      params: { path: { tokenId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Revoke an API token
-   * @param tokenId - The token identifier
-   * @returns Promise that resolves when the token is revoked
-   * @throws {ApiError} if the request fails
-   */
-  async revokeApiToken(tokenId) {
-    await this.#api.DELETE("/api-tokens/{tokenId}/", {
-      params: { path: { tokenId } }
-    });
-  }
-};
-
-// src/services/auth.ts
-var Auth = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * Login with email and password
-   * @param credentials - Login credentials
-   * @returns Promise that resolves with the auth response containing access token
-   * @throws {ApiError} if the request fails
-   */
-  async loginAccount(credentials) {
-    const { data } = await this.#api.POST("/auth/login", {
-      body: credentials
-    });
-    return data;
-  }
-  /**
-   * Sign up a new account
-   * @param credentials - Signup details
-   * @returns Promise that resolves with the auth response containing access token
-   * @throws {ApiError} if the request fails
-   */
-  async signupAccount(credentials) {
-    const { data } = await this.#api.POST("/auth/signup", {
-      body: credentials
-    });
-    return data;
-  }
-  /**
-   * Logout and invalidate the current access token
-   * @returns Promise that resolves when logout is complete
-   * @throws {ApiError} if the request fails
-   */
-  async logoutAccount() {
-    await this.#api.POST("/auth/logout");
-  }
-};
-
-// src/services/comments.ts
-var Comments = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all comments on a file
-   * @param fileId - File ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of comments
-   * @throws {ApiError} if the request fails
-   */
-  async listComments(fileId, query) {
-    const { data } = await this.#api.GET("/files/{fileId}/comments", {
-      params: { path: { fileId }, query }
-    });
-    return data;
-  }
-  /**
-   * Create a new comment on a file
-   * @param fileId - File ID
-   * @param comment - Comment creation request
-   * @returns Promise that resolves with the created comment
-   * @throws {ApiError} if the request fails
-   */
-  async createComment(fileId, comment) {
-    const { data } = await this.#api.POST("/files/{fileId}/comments", {
-      params: { path: { fileId } },
-      body: comment
-    });
-    return data;
-  }
-  /**
-   * Update a comment
-   * @param commentId - Comment ID
-   * @param updates - Comment update request
-   * @returns Promise that resolves with the updated comment
-   * @throws {ApiError} if the request fails
-   */
-  async updateComment(commentId, updates) {
-    const { data } = await this.#api.PATCH("/comments/{commentId}", {
-      params: { path: { commentId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a comment
-   * @param commentId - Comment ID
-   * @returns Promise that resolves when the comment is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteComment(commentId) {
-    await this.#api.DELETE("/comments/{commentId}", {
-      params: { path: { commentId } }
-    });
-  }
-};
-
-// src/services/documents.ts
-var Documents = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List documents in a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of documents
-   * @throws {ApiError} if the request fails
-   */
-  async listDocuments(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/documents",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-  /**
-   * Get document details by ID
-   * @param documentId - Document ID
-   * @returns Promise that resolves with the document details
-   * @throws {ApiError} if the request fails
-   */
-  async getDocument(documentId) {
-    const { data } = await this.#api.GET("/documents/{documentId}", {
-      params: { path: { documentId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new document
-   * @param workspaceId - Workspace ID
-   * @param document - Document creation request
-   * @returns Promise that resolves with the created document
-   * @throws {ApiError} if the request fails
-   */
-  async createDocument(workspaceId, document) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspaceId}/documents",
-      {
-        params: { path: { workspaceId } },
-        body: document
-      }
-    );
-    return data;
-  }
-  /**
-   * Update an existing document
-   * @param documentId - Document ID
-   * @param updates - Document update request
-   * @returns Promise that resolves with the updated document
-   * @throws {ApiError} if the request fails
-   */
-  async updateDocument(documentId, updates) {
-    const { data } = await this.#api.PATCH("/documents/{documentId}", {
-      params: { path: { documentId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a document
-   * @param documentId - Document ID
-   * @returns Promise that resolves when the document is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteDocument(documentId) {
-    await this.#api.DELETE("/documents/{documentId}", {
-      params: { path: { documentId } }
-    });
-  }
-};
-
-// src/services/files.ts
-var Files = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * Upload one or more files to a workspace
-   * @param workspaceId - Workspace ID
-   * @param files - File or array of files to upload
-   * @returns Promise that resolves with the uploaded file metadata
-   * @throws {ApiError} if the request fails
-   */
-  async uploadFiles(workspaceId, files) {
-    const formData = new FormData();
-    const fileArray = Array.isArray(files) ? files : [files];
-    for (const file of fileArray) {
-      const name = file instanceof File ? file.name : "file";
-      formData.append("files", file, name);
-    }
-    const { data } = await this.#api.POST("/workspaces/{workspaceId}/files/", {
-      params: { path: { workspaceId } },
-      // Schema types multipart as unknown[], but openapi-fetch needs FormData.
-      body: formData,
-      bodySerializer: (formData2) => formData2,
-      // Remove Content-Type so browser sets multipart/form-data with boundary.
-      headers: { "Content-Type": null }
-    });
-    return data;
-  }
-  /**
-   * List files in a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (formats, limit, after)
-   * @returns Promise that resolves with a paginated list of files
-   * @throws {ApiError} if the request fails
-   */
-  async listFiles(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspaceId}/files/", {
-      params: { path: { workspaceId }, query }
-    });
-    return data;
-  }
-  /**
-   * Get file metadata by ID
-   * @param fileId - File ID
-   * @returns Promise that resolves with the file metadata
-   * @throws {ApiError} if the request fails
-   */
-  async getFile(fileId) {
-    const { data } = await this.#api.GET("/files/{fileId}", {
-      params: { path: { fileId } }
-    });
-    return data;
-  }
-  /**
-   * Download a file by ID
-   * @param fileId - File ID
-   * @returns Promise that resolves with the file response
-   * @throws {ApiError} if the request fails
-   */
-  async downloadFile(fileId) {
-    const { response } = await this.#api.GET("/files/{fileId}/content", {
-      params: { path: { fileId } },
-      parseAs: "stream"
-    });
-    return response;
-  }
-  /**
-   * Update a file's metadata
-   * @param fileId - File ID
-   * @param updates - File update request
-   * @returns Promise that resolves with the updated file
-   * @throws {ApiError} if the request fails
-   */
-  async updateFile(fileId, updates) {
-    const { data } = await this.#api.PATCH("/files/{fileId}", {
-      params: { path: { fileId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a file
-   * @param fileId - File ID
-   * @returns Promise that resolves when the file is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteFile(fileId) {
-    await this.#api.DELETE("/files/{fileId}", {
-      params: { path: { fileId } }
-    });
-  }
-  /**
-   * Download files as an archive
-   * @param workspaceId - Workspace ID
-   * @param request - Download request with format and optional file IDs
-   * @returns Promise that resolves with the archive response
-   * @throws {ApiError} if the request fails
-   */
-  async downloadFiles(workspaceId, request) {
-    const { response } = await this.#api.GET(
-      "/workspaces/{workspaceId}/files/batch",
-      {
-        params: { path: { workspaceId } },
-        body: request,
-        parseAs: "stream"
-      }
-    );
-    return response;
-  }
-  /**
-   * Delete multiple files
-   * @param workspaceId - Workspace ID
-   * @param request - Delete request with file IDs
-   * @returns Promise that resolves when the files are deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteFiles(workspaceId, request) {
-    await this.#api.DELETE("/workspaces/{workspaceId}/files/batch", {
-      params: { path: { workspaceId } },
-      body: request
-    });
-  }
-};
-
-// src/services/integrations.ts
-var Integrations = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List integrations for a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of integrations
-   * @throws {ApiError} if the request fails
-   */
-  async listIntegrations(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/integrations/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-  /**
-   * Get integration details by ID
-   * @param integrationId - Integration ID
-   * @returns Promise that resolves with the integration details
-   * @throws {ApiError} if the request fails
-   */
-  async getIntegration(integrationId) {
-    const { data } = await this.#api.GET("/integrations/{integrationId}/", {
-      params: { path: { integrationId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new integration
-   * @param workspaceId - Workspace ID
-   * @param integration - Integration creation request
-   * @returns Promise that resolves with the created integration
-   * @throws {ApiError} if the request fails
-   */
-  async createIntegration(workspaceId, integration) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspaceId}/integrations/",
-      {
-        params: { path: { workspaceId } },
-        body: integration
-      }
-    );
-    return data;
-  }
-  /**
-   * Update an existing integration
-   * @param integrationId - Integration ID
-   * @param updates - Integration update request
-   * @returns Promise that resolves with the updated integration
-   * @throws {ApiError} if the request fails
-   */
-  async updateIntegration(integrationId, updates) {
-    const { data } = await this.#api.PUT("/integrations/{integrationId}/", {
-      params: { path: { integrationId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Update integration credentials
-   * @param integrationId - Integration ID
-   * @param credentials - New credentials
-   * @returns Promise that resolves with the updated integration
-   * @throws {ApiError} if the request fails
-   */
-  async updateIntegrationCredentials(integrationId, credentials) {
-    const { data } = await this.#api.PATCH(
-      "/integrations/{integrationId}/credentials/",
-      {
-        params: { path: { integrationId } },
-        body: credentials
-      }
-    );
-    return data;
-  }
-  /**
-   * Delete an integration
-   * @param integrationId - Integration ID
-   * @returns Promise that resolves when the integration is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteIntegration(integrationId) {
-    await this.#api.DELETE("/integrations/{integrationId}/", {
-      params: { path: { integrationId } }
-    });
-  }
-};
-
-// src/services/invites.ts
-var Invites = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all invitations for a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (role, sortBy, order, limit, after)
-   * @returns Promise that resolves with a paginated list of invitations
-   * @throws {ApiError} if the request fails
-   */
-  async listInvites(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspaceId}/invites/", {
-      params: { path: { workspaceId }, query }
-    });
-    return data;
-  }
-  /**
-   * Send an invitation to join a workspace
-   * @param workspaceId - Workspace ID
-   * @param invite - Invitation request
-   * @returns Promise that resolves with the created invitation
-   * @throws {ApiError} if the request fails
-   */
-  async sendInvite(workspaceId, invite) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspaceId}/invites/",
-      {
-        params: { path: { workspaceId } },
-        body: invite
-      }
-    );
-    return data;
-  }
-  /**
-   * Cancel a pending invitation
-   * @param inviteId - Invite ID
-   * @returns Promise that resolves when the invitation is canceled
-   * @throws {ApiError} if the request fails
-   */
-  async cancelInvite(inviteId) {
-    await this.#api.DELETE("/invites/{inviteId}/", {
-      params: { path: { inviteId } }
-    });
-  }
-  /**
-   * Reply to an invitation (accept or decline)
-   * @param inviteId - Invite ID
-   * @param reply - Reply request
-   * @returns Promise that resolves with the updated invitation
-   * @throws {ApiError} if the request fails
-   */
-  async replyToInvite(inviteId, reply) {
-    const { data } = await this.#api.POST("/invites/{inviteId}/", {
-      params: { path: { inviteId } },
-      body: reply
-    });
-    return data;
-  }
-  /**
-   * Generate a shareable invite code for a workspace
-   * @param workspaceId - Workspace ID
-   * @param options - Invite code generation options
-   * @returns Promise that resolves with the generated invite code
-   * @throws {ApiError} if the request fails
-   */
-  async generateInviteCode(workspaceId, options) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspaceId}/invites/code/",
-      {
-        params: { path: { workspaceId } },
-        body: options
-      }
-    );
-    return data;
-  }
-  /**
-   * Reply to an invite code (accept or decline)
-   * @param inviteCode - The invite code
-   * @param reply - Optional reply request (defaults to accept if not provided)
-   * @returns Promise that resolves with the member details if accepted, null if declined
-   * @throws {ApiError} if the request fails
-   */
-  async replyToInviteCode(inviteCode, reply) {
-    const { data } = await this.#api.POST("/invites/code/{inviteCode}/", {
-      params: { path: { inviteCode } },
-      body: reply ?? null
-    });
-    return data;
-  }
-  /**
-   * Preview an invite code without joining
-   * @param inviteCode - The invite code
-   * @returns Promise that resolves with the invite preview details
-   * @throws {ApiError} if the request fails
-   */
-  async previewInvite(inviteCode) {
-    const { data } = await this.#api.GET("/invites/code/{inviteCode}/", {
-      params: { path: { inviteCode } }
-    });
-    return data;
-  }
-};
-
-// src/services/members.ts
-var Members = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List members of a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (role, has2fa, sortBy, order, limit, after)
-   * @returns Promise that resolves with a paginated list of members
-   * @throws {ApiError} if the request fails
-   */
-  async listMembers(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspaceId}/members/", {
-      params: { path: { workspaceId }, query }
-    });
-    return data;
-  }
-  /**
-   * Get member details by account ID
-   * @param workspaceId - Workspace ID
-   * @param accountId - Account ID
-   * @returns Promise that resolves with the member details
-   * @throws {ApiError} if the request fails
-   */
-  async getMember(workspaceId, accountId) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/members/{accountId}/",
-      {
-        params: {
-          path: { workspaceId, accountId }
-        }
-      }
-    );
-    return data;
-  }
-  /**
-   * Update a member's role
-   * @param workspaceId - Workspace ID
-   * @param accountId - Account ID
-   * @param updates - New role for the member
-   * @returns Promise that resolves with the updated member
-   * @throws {ApiError} if the request fails
-   */
-  async updateMember(workspaceId, accountId, updates) {
-    const { data } = await this.#api.PATCH(
-      "/workspaces/{workspaceId}/members/{accountId}/role",
-      {
-        params: {
-          path: { workspaceId, accountId }
-        },
-        body: updates
-      }
-    );
-    return data;
-  }
-  /**
-   * Remove a member from a workspace
-   * @param workspaceId - Workspace ID
-   * @param accountId - Account ID
-   * @returns Promise that resolves when the member is removed
-   * @throws {ApiError} if the request fails
-   */
-  async removeMember(workspaceId, accountId) {
-    await this.#api.DELETE("/workspaces/{workspaceId}/members/{accountId}/", {
-      params: { path: { workspaceId, accountId } }
-    });
-  }
-  /**
-   * Leave a workspace
-   * @param workspaceId - Workspace ID
-   * @returns Promise that resolves when the member has left
-   * @throws {ApiError} if the request fails
-   */
-  async leaveWorkspace(workspaceId) {
-    await this.#api.POST("/workspaces/{workspaceId}/members/leave", {
-      params: { path: { workspaceId } }
-    });
-  }
-};
-
-// src/services/notifications.ts
-var Notifications = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List notifications for the authenticated account
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of notifications
-   * @throws {ApiError} if the request fails
-   */
-  async listNotifications(query) {
-    const { data } = await this.#api.GET("/notifications/", {
-      params: { query }
-    });
-    return data;
-  }
-  /**
-   * Get the unread notifications count for the authenticated account
-   * @returns Promise that resolves with the unread status
-   * @throws {ApiError} if the request fails
-   */
-  async getUnreadNotificationsStatus() {
-    const { data } = await this.#api.GET("/notifications/unread");
-    return data;
-  }
-};
-
-// src/services/runs.ts
-var Runs = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List integration runs for a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of integration runs
-   * @throws {ApiError} if the request fails
-   */
-  async listRuns(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspaceId}/runs/", {
-      params: { path: { workspaceId }, query }
-    });
-    return data;
-  }
-  /**
-   * Get integration run details by ID
-   * @param runId - Run ID
-   * @returns Promise that resolves with the integration run details
-   * @throws {ApiError} if the request fails
-   */
-  async getRun(runId) {
-    const { data } = await this.#api.GET("/runs/{runId}", {
-      params: { path: { runId } }
-    });
-    return data;
-  }
-};
-
-// src/services/status.ts
-var Status = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * Check the health status of the API
-   * @param options - Health check options
-   * @returns Promise that resolves with the API health status
-   */
-  async checkHealth(options) {
-    const { data, error } = await this.#api.GET("/health", {
-      params: { path: { version: "v1" } },
-      body: options ?? {}
-    });
-    return data ?? error;
-  }
-};
-
-// src/services/webhooks.ts
-var Webhooks = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all webhooks in a workspace
-   * @param workspaceId - Workspace ID
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of webhooks
-   * @throws {ApiError} if the request fails
-   */
-  async listWebhooks(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/webhooks/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-  /**
-   * Get a specific webhook by ID
-   * @param webhookId - Webhook ID
-   * @returns Promise that resolves with the webhook details
-   * @throws {ApiError} if the request fails
-   */
-  async getWebhook(webhookId) {
-    const { data } = await this.#api.GET("/webhooks/{webhookId}/", {
-      params: { path: { webhookId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new webhook
-   * @param workspaceId - Workspace ID
-   * @param webhook - Webhook creation request
-   * @returns Promise that resolves with the created webhook
-   * @throws {ApiError} if the request fails
-   */
-  async createWebhook(workspaceId, webhook) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspaceId}/webhooks/",
-      {
-        params: { path: { workspaceId } },
-        body: webhook
-      }
-    );
-    return data;
-  }
-  /**
-   * Update an existing webhook
-   * @param webhookId - Webhook ID
-   * @param updates - Webhook update request
-   * @returns Promise that resolves with the updated webhook
-   * @throws {ApiError} if the request fails
-   */
-  async updateWebhook(webhookId, updates) {
-    const { data } = await this.#api.PUT("/webhooks/{webhookId}/", {
-      params: { path: { webhookId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a webhook
-   * @param webhookId - Webhook ID
-   * @returns Promise that resolves when the webhook is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteWebhook(webhookId) {
-    await this.#api.DELETE("/webhooks/{webhookId}/", {
-      params: { path: { webhookId } }
-    });
-  }
-  /**
-   * Test a webhook by sending a test payload
-   * @param webhookId - Webhook ID
-   * @param options - Test webhook options
-   * @returns Promise that resolves with the test result
-   * @throws {ApiError} if the request fails
-   */
-  async testWebhook(webhookId, options) {
-    const { data } = await this.#api.POST("/webhooks/{webhookId}/test/", {
-      params: { path: { webhookId } },
-      body: options ?? {}
-    });
-    return data;
-  }
-};
-
-// src/services/workspaces.ts
-var Workspaces = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all workspaces
-   * @param query - Optional pagination parameters (limit, after)
-   * @returns Promise that resolves with a paginated list of workspaces
-   * @throws {ApiError} if the request fails
-   */
-  async listWorkspaces(query) {
-    const { data } = await this.#api.GET("/workspaces/", {
-      params: { query }
-    });
-    return data;
-  }
-  /**
-   * Get workspace details by ID
-   * @param workspaceId - Workspace ID
-   * @returns Promise that resolves with the workspace details
-   * @throws {ApiError} if the request fails
-   */
-  async getWorkspace(workspaceId) {
-    const { data } = await this.#api.GET("/workspaces/{workspaceId}/", {
-      params: { path: { workspaceId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new workspace
-   * @param workspace - Workspace creation request
-   * @returns Promise that resolves with the created workspace
-   * @throws {ApiError} if the request fails
-   */
-  async createWorkspace(workspace) {
-    const { data } = await this.#api.POST("/workspaces/", {
-      body: workspace
-    });
-    return data;
-  }
-  /**
-   * Update an existing workspace
-   * @param workspaceId - Workspace ID
-   * @param updates - Workspace update request
-   * @returns Promise that resolves with the updated workspace
-   * @throws {ApiError} if the request fails
-   */
-  async updateWorkspace(workspaceId, updates) {
-    const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/", {
-      params: { path: { workspaceId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a workspace
-   * @param workspaceId - Workspace ID
-   * @returns Promise that resolves when the workspace is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async deleteWorkspace(workspaceId) {
-    await this.#api.DELETE("/workspaces/{workspaceId}/", {
-      params: { path: { workspaceId } }
-    });
-  }
-  /**
-   * Get notification settings for the authenticated user in a workspace
-   * @param workspaceId - Workspace ID
-   * @returns Promise that resolves with the notification settings
-   * @throws {ApiError} if the request fails
-   */
-  async getNotificationSettings(workspaceId) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspaceId}/notifications",
-      {
-        params: { path: { workspaceId } }
-      }
-    );
-    return data;
-  }
-  /**
-   * Update notification settings for the authenticated user in a workspace
-   * @param workspaceId - Workspace ID
-   * @param settings - Notification settings update request
-   * @returns Promise that resolves with the updated notification settings
-   * @throws {ApiError} if the request fails
-   */
-  async updateNotificationSettings(workspaceId, settings) {
-    const { data } = await this.#api.PATCH(
-      "/workspaces/{workspaceId}/notifications",
-      {
-        params: { path: { workspaceId } },
-        body: settings
-      }
-    );
-    return data;
-  }
-};
-
-export { Account, Activities, Annotations, ApiTokens, Auth, Comments, Documents, Files, Integrations, Invites, Members, Notifications, Runs, Status, Webhooks, Workspaces };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { Account, Activities, ApiTokens, Auth, Connections, Contexts, Files, Invites, Members, Notifications, Pipelines, Policies, Runs, Status, Webhooks, Workspaces };