@nvisy/sdk 0.1.0 → 0.2.0

package/dist/services/index.js

@@ -0,0 +1,956 @@
+// src/services/account.ts
+var AccountService = 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 get() {
+    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 update(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 delete() {
+    await this.#api.DELETE("/account");
+  }
+};
+
+// src/services/activities.ts
+var ActivitiesService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List activities for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of activities
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/activities/",
+      {
+        params: { path: { workspaceId }, query }
+      }
+    );
+    return data;
+  }
+};
+
+// src/services/annotations.ts
+var AnnotationsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List annotations for a file
+   * @param fileId - File ID
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of annotations
+   * @throws {ApiError} if the request fails
+   */
+  async list(fileId, query) {
+    const { data } = await this.#api.GET("/files/{file_id}/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 get(annotationId) {
+    const { data } = await this.#api.GET("/annotations/{annotation_id}", {
+      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 create(fileId, annotation) {
+    const { data } = await this.#api.POST("/files/{file_id}/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 update(annotationId, updates) {
+    const { data } = await this.#api.PATCH("/annotations/{annotation_id}", {
+      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 delete(annotationId) {
+    await this.#api.DELETE("/annotations/{annotation_id}", {
+      params: { path: { annotationId } }
+    });
+  }
+};
+
+// src/services/api-tokens.ts
+var ApiTokensService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List all API tokens for the authenticated account
+   * @param options - Pagination options
+   * @returns Promise that resolves with the list of API tokens
+   * @throws {ApiError} if the request fails
+   */
+  async list(options) {
+    const { data } = await this.#api.GET("/api-tokens/", {
+      params: { query: options }
+    });
+    return data;
+  }
+  /**
+   * Get a specific API token by access token
+   * @param accessToken - The access token identifier
+   * @returns Promise that resolves with the API token details
+   * @throws {ApiError} if the request fails
+   */
+  async get(accessToken) {
+    const { data } = await this.#api.GET(
+      "/api-tokens/{access_token}/",
+      {
+        params: { path: { access_token: accessToken } }
+      }
+    );
+    return data;
+  }
+  /**
+   * Create a new API token
+   * @param token - Token creation request
+   * @returns Promise that resolves with the created token (includes secret, shown only once)
+   * @throws {ApiError} if the request fails
+   */
+  async create(token) {
+    const { data } = await this.#api.POST("/api-tokens/", {
+      body: token
+    });
+    return data;
+  }
+  /**
+   * Update an existing API token
+   * @param accessToken - The access token identifier
+   * @param updates - Token update request
+   * @returns Promise that resolves with the updated token
+   * @throws {ApiError} if the request fails
+   */
+  async update(accessToken, updates) {
+    const { data } = await this.#api.PATCH(
+      "/api-tokens/{access_token}/",
+      {
+        params: { path: { access_token: accessToken } },
+        body: updates
+      }
+    );
+    return data;
+  }
+  /**
+   * Revoke an API token
+   * @param accessToken - The access token identifier
+   * @returns Promise that resolves when the token is revoked
+   * @throws {ApiError} if the request fails
+   */
+  async revoke(accessToken) {
+    await this.#api.DELETE(
+      "/api-tokens/{access_token}/",
+      {
+        params: { path: { access_token: accessToken } }
+      }
+    );
+  }
+};
+
+// src/services/auth.ts
+var AuthService = 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 login(credentials) {
+    const { data } = await this.#api.POST("/auth/login", {
+      body: credentials
+    });
+    return data;
+  }
+  /**
+   * Sign up a new account
+   * @param details - Signup details
+   * @returns Promise that resolves with the auth response containing access token
+   * @throws {ApiError} if the request fails
+   */
+  async signup(details) {
+    const { data } = await this.#api.POST("/auth/signup", {
+      body: details
+    });
+    return data;
+  }
+};
+
+// src/services/comments.ts
+var CommentsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List all comments on a file
+   * @param fileId - File ID
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of comments
+   * @throws {ApiError} if the request fails
+   */
+  async list(fileId, query) {
+    const { data } = await this.#api.GET("/files/{file_id}/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 create(fileId, comment) {
+    const { data } = await this.#api.POST("/files/{file_id}/comments", {
+      params: { path: { fileId } },
+      body: comment
+    });
+    return data;
+  }
+  /**
+   * Delete a comment
+   * @param fileId - File ID
+   * @param commentId - Comment ID
+   * @returns Promise that resolves when the comment is deleted
+   * @throws {ApiError} if the request fails
+   */
+  async delete(fileId, commentId) {
+    await this.#api.DELETE("/files/{file_id}/comments/{comment_id}", {
+      params: { path: { fileId, commentId } }
+    });
+  }
+};
+
+// src/services/documents.ts
+var DocumentsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List documents in a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of documents
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/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 get(documentId) {
+    const { data } = await this.#api.GET("/documents/{document_id}", {
+      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 create(workspaceId, document) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspace_id}/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 update(documentId, updates) {
+    const { data } = await this.#api.PATCH("/documents/{document_id}", {
+      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 delete(documentId) {
+    await this.#api.DELETE("/documents/{document_id}", {
+      params: { path: { documentId } }
+    });
+  }
+};
+
+// src/services/files.ts
+var FilesService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List files in a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (formats, sortBy, order, offset, limit)
+   * @returns Promise that resolves with the list of files
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspace_id}/files/", {
+      params: { path: { workspaceId }, query }
+    });
+    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 download(fileId) {
+    const { response } = await this.#api.GET("/files/{file_id}", {
+      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 update(fileId, updates) {
+    const { data } = await this.#api.PATCH("/files/{file_id}", {
+      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 delete(fileId) {
+    await this.#api.DELETE("/files/{file_id}", {
+      params: { path: { fileId } }
+    });
+  }
+  /**
+   * Download multiple files
+   * @param workspaceId - Workspace ID
+   * @param request - Download request with file IDs
+   * @returns Promise that resolves with the download response
+   * @throws {ApiError} if the request fails
+   */
+  async downloadMultiple(workspaceId, request) {
+    const { response } = await this.#api.POST(
+      "/workspaces/{workspace_id}/files/download",
+      {
+        params: { path: { workspaceId } },
+        body: request,
+        parseAs: "stream"
+      }
+    );
+    return response;
+  }
+  /**
+   * Download files as an archive
+   * @param workspaceId - Workspace ID
+   * @param request - Archive download request
+   * @returns Promise that resolves with the archive response
+   * @throws {ApiError} if the request fails
+   */
+  async downloadArchive(workspaceId, request) {
+    const { response } = await this.#api.POST(
+      "/workspaces/{workspace_id}/files/archive",
+      {
+        params: { path: { workspaceId } },
+        body: request,
+        parseAs: "stream"
+      }
+    );
+    return response;
+  }
+};
+
+// src/services/integrations.ts
+var IntegrationsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List integrations for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (integrationType, offset, limit)
+   * @returns Promise that resolves with the list of integrations
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/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 get(integrationId) {
+    const { data } = await this.#api.GET("/integrations/{integration_id}/", {
+      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 create(workspaceId, integration) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspace_id}/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 update(integrationId, updates) {
+    const { data } = await this.#api.PUT("/integrations/{integration_id}/", {
+      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 updateCredentials(integrationId, credentials) {
+    const { data } = await this.#api.PATCH(
+      "/integrations/{integration_id}/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 delete(integrationId) {
+    await this.#api.DELETE("/integrations/{integration_id}/", {
+      params: { path: { integrationId } }
+    });
+  }
+};
+
+// src/services/invites.ts
+var InvitesService = 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, offset, limit)
+   * @returns Promise that resolves with the list of invitations
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/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 send(workspaceId, invite) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspace_id}/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 cancel(inviteId) {
+    await this.#api.DELETE("/invites/{invite_id}/", {
+      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 reply(inviteId, reply) {
+    const { data } = await this.#api.PATCH("/invites/{invite_id}/reply/", {
+      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 generateCode(workspaceId, options) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspace_id}/invites/code/",
+      {
+        params: { path: { workspaceId } },
+        body: options
+      }
+    );
+    return data;
+  }
+  /**
+   * Join a workspace using an invite code
+   * @param inviteCode - The invite code
+   * @returns Promise that resolves with the member details
+   * @throws {ApiError} if the request fails
+   */
+  async joinWithCode(inviteCode) {
+    const { data } = await this.#api.POST("/invites/{invite_code}/join/", {
+      params: { path: { inviteCode } }
+    });
+    return data;
+  }
+};
+
+// src/services/members.ts
+var MembersService = 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, offset, limit)
+   * @returns Promise that resolves with the list of members
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/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 get(workspaceId, accountId) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/members/{account_id}/",
+      {
+        params: { path: { workspaceId, accountId } }
+      }
+    );
+    return data;
+  }
+  /**
+   * Update a member's role
+   * @param workspaceId - Workspace ID
+   * @param accountId - Account ID
+   * @param role - New role for the member
+   * @returns Promise that resolves with the updated member
+   * @throws {ApiError} if the request fails
+   */
+  async updateRole(workspaceId, accountId, role) {
+    const { data } = await this.#api.PATCH(
+      "/workspaces/{workspace_id}/members/{account_id}/role",
+      {
+        params: { path: { workspaceId, accountId } },
+        body: role
+      }
+    );
+    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 remove(workspaceId, accountId) {
+    await this.#api.DELETE("/workspaces/{workspace_id}/members/{account_id}/", {
+      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 leave(workspaceId) {
+    await this.#api.POST("/workspaces/{workspace_id}/members/leave", {
+      params: { path: { workspaceId } }
+    });
+  }
+};
+
+// src/services/notifications.ts
+var NotificationsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List notifications for the authenticated account
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of notifications
+   * @throws {ApiError} if the request fails
+   */
+  async list(query) {
+    const { data } = await this.#api.GET("/notifications/", {
+      params: { query }
+    });
+    return data;
+  }
+};
+
+// src/services/runs.ts
+var RunsService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List integration runs for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of integration runs
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspace_id}/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 get(runId) {
+    const { data } = await this.#api.GET("/runs/{run_id}", {
+      params: { path: { runId } }
+    });
+    return data;
+  }
+};
+
+// src/services/status.ts
+var StatusService = 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 health(options) {
+    const { data, error } = await this.#api.GET("/health", {
+      params: { path: { version: "v1" } },
+      body: options ?? {}
+    });
+    return data ?? error;
+  }
+};
+
+// src/services/webhooks.ts
+var WebhooksService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List all webhooks in a workspace
+   * @param workspaceId - Workspace ID
+   * @returns Promise that resolves with the list of webhooks
+   * @throws {ApiError} if the request fails
+   */
+  async list(workspaceId) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspace_id}/webhooks/",
+      {
+        params: { path: { workspaceId } }
+      }
+    );
+    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 get(webhookId) {
+    const { data } = await this.#api.GET("/webhooks/{webhook_id}/", {
+      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 (includes secret, shown only once)
+   * @throws {ApiError} if the request fails
+   */
+  async create(workspaceId, webhook) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspace_id}/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 update(webhookId, updates) {
+    const { data } = await this.#api.PUT("/webhooks/{webhook_id}/", {
+      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 delete(webhookId) {
+    await this.#api.DELETE("/webhooks/{webhook_id}/", {
+      params: { path: { webhookId } }
+    });
+  }
+};
+
+// src/services/workspaces.ts
+var WorkspacesService = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List all workspaces
+   * @param query - Optional query parameters (offset, limit)
+   * @returns Promise that resolves with the list of workspaces
+   * @throws {ApiError} if the request fails
+   */
+  async list(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 get(workspaceId) {
+    const { data } = await this.#api.GET("/workspaces/{workspace_id}/", {
+      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 create(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 update(workspaceId, updates) {
+    const { data } = await this.#api.PATCH("/workspaces/{workspace_id}/", {
+      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 delete(workspaceId) {
+    await this.#api.DELETE("/workspaces/{workspace_id}/", {
+      params: { path: { workspaceId } }
+    });
+  }
+};
+
+export { AccountService, ActivitiesService, AnnotationsService, ApiTokensService, AuthService, CommentsService, DocumentsService, FilesService, IntegrationsService, InvitesService, MembersService, NotificationsService, RunsService, StatusService, WebhooksService, WorkspacesService };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map