@nvisy/sdk 0.2.0 → 0.3.0

package/dist/{client-D6GtLRbO.d.ts → client-DQRisDAK.d.ts}

@@ -1,82 +1,12 @@
-import { A as Account, U as UpdateAccount, a2 as Pagination, a as Activity, c as Annotation, C as CreateAnnotation, d as UpdateAnnotation, e as ApiToken, h as CreateApiToken, f as ApiTokenWithSecret, i as UpdateApiToken, L as Login, j as AuthToken, S as Signup, k as Comment, l as CreateComment, D as Document, n as CreateDocument, o as UpdateDocument, v as ListFilesQuery, F as File, q as UpdateFile, s as DownloadMultipleFilesRequest, t as DownloadArchivedFilesRequest, H as ListIntegrationsQuery, I as Integration, y as CreateIntegration, z as UpdateIntegration, B as UpdateIntegrationCredentials, V as ListInvitesQuery, J as Invite, K as CreateInvite, R as ReplyInvite, M as GenerateInviteCode, N as InviteCode, Y as Member, _ as ListMembersQuery, Z as UpdateMemberRole, a0 as Notification, a3 as IntegrationRun, a6 as CheckHealth, a4 as MonitorStatus, a7 as Webhook, a9 as CreateWebhook, a8 as WebhookWithSecret, aa as UpdateWebhook, ac as Workspace, ad as CreateWorkspace, ae as UpdateWorkspace, ah as paths } from './workspace-3RLqaMcj.js';
-import { Client as Client$1 } from 'openapi-fetch';
-
-/**
- * @fileoverview Configuration types and constants for the Nvisy SDK.
- *
- * This module provides configuration interfaces, default values, and environment
- * variable names used throughout the SDK.
- *
- * @module config
- */
-/**
- * Current SDK version.
- *
- * Used in the default user agent string and for version tracking.
- */
-declare const VERSION = "0.2.0";
-/**
- * Configuration options for creating a Nvisy client.
- *
- * The `apiToken` field is required for authentication. All other fields are optional
- * and will use sensible defaults when omitted.
- *
- * @example
- * ```typescript
- * const config: ClientConfig = {
- *   apiToken: "your-api-token",
- *   baseUrl: "https://api.nvisy.com",
- *   headers: { "X-Custom-Header": "value" },
- * };
- * const client = new Client(config);
- * ```
- */
-interface ClientConfig {
-    /**
-     * API token for authentication.
-     *
-     * Tokens can be obtained from the Nvisy dashboard or via the auth endpoints.
-     */
-    apiToken: string;
-    /**
-     * Base URL for the Nvisy API.
-     *
-     * @default "https://api.nvisy.com"
-     */
-    baseUrl?: string;
-    /**
-     * Custom headers to include with every request.
-     *
-     * These headers are merged with the default headers (Content-Type, User-Agent,
-     * and Authorization). Custom headers take precedence over defaults if there
-     * are conflicts.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Custom user agent string to identify your application.
-     *
-     * @default "@nvisy/sdk v.{version}"
-     */
-    userAgent?: string;
-}
-/**
- * Default configuration values used when options are not explicitly provided.
- */
-declare const DEFAULTS: {
-    /**
-     * Default base URL for the Nvisy API.
-     */
-    readonly BASE_URL: "https://api.nvisy.com";
-    /**
-     * Default user agent string.
-     */
-    readonly USER_AGENT: "@nvisy/sdk v.0.2.0";
-};
+import { Client } from 'openapi-fetch';
+import { C as ClientConfig } from './config-L7FKq_q5.js';
+import { L as Login, A as AuthToken, S as Signup, p as paths } from './auth-CncOz2vx.js';
+import { A as Account$1, U as UpdateAccount, aa as CursorPagination, c as ActivitiesPage, f as AnnotationsPage, d as Annotation, C as CreateAnnotation, e as UpdateAnnotation, l as ApiTokensPage, g as ApiToken, j as CreateApiToken, h as ApiTokenWithJWT, k as UpdateApiToken, p as CommentsPage, n as CreateComment, m as Comment, o as UpdateComment, s as DocumentsPage, D as Document, q as CreateDocument, r as UpdateDocument, F as File, L as ListFiles, z as FilesPage, t as UpdateFile, v as DownloadFiles, w as DeleteFiles, K as IntegrationsPage, I as Integration, B as CreateIntegration, E as UpdateIntegration, G as UpdateIntegrationCredentials, W as ListInvites, _ as InvitesPage, N as CreateInvite, M as Invite, R as ReplyInvite, O as GenerateInviteCode, Q as InviteCode, $ as Member, Z as InvitePreview, a1 as ListMembers, a3 as MembersPage, a0 as UpdateMember, a9 as NotificationsPage, a8 as UnreadStatus, ac as IntegrationRunsPage, ab as IntegrationRun, af as CheckHealth, ad as MonitorStatus, an as WebhooksPage, ag as Webhook, ah as CreateWebhook, ai as UpdateWebhook, aj as TestWebhook, ak as WebhookResult, as as WorkspacesPage, ao as Workspace, ap as CreateWorkspace, aq as UpdateWorkspace, a6 as NotificationSettings, a7 as UpdateNotificationSettings } from './workspace-BjdbMWsa.js';
 
 /**
  * Service for handling account operations
  */
-declare class AccountService {
+declare class Account {
     #private;
     constructor(api: ApiClient);
     /**
@@ -84,59 +14,59 @@ declare class AccountService {
      * @returns Promise that resolves with the account details
      * @throws {ApiError} if the request fails
      */
-    get(): Promise<Account>;
+    getAccount(): Promise<Account$1>;
     /**
      * 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
      */
-    update(updates: UpdateAccount): Promise<Account>;
+    updateAccount(updates: UpdateAccount): Promise<Account$1>;
     /**
      * Delete the authenticated user's account
      * @returns Promise that resolves when the account is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(): Promise<void>;
+    deleteAccount(): Promise<void>;
 }
 
 /**
  * Service for handling workspace activity operations
  */
-declare class ActivitiesService {
+declare class Activities {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of activities
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string, query?: Pagination): Promise<Activity[]>;
+    listActivities(workspaceId: string, query?: CursorPagination): Promise<ActivitiesPage>;
 }
 
 /**
  * Service for handling file annotation operations
  */
-declare class AnnotationsService {
+declare class Annotations {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of annotations
      * @throws {ApiError} if the request fails
      */
-    list(fileId: string, query?: Pagination): Promise<Annotation[]>;
+    listAnnotations(fileId: string, query?: CursorPagination): Promise<AnnotationsPage>;
     /**
      * Get annotation details by ID
      * @param annotationId - Annotation ID
      * @returns Promise that resolves with the annotation details
      * @throws {ApiError} if the request fails
      */
-    get(annotationId: string): Promise<Annotation>;
+    getAnnotation(annotationId: string): Promise<Annotation>;
     /**
      * Create a new annotation
      * @param fileId - File ID
@@ -144,7 +74,7 @@ declare class AnnotationsService {
      * @returns Promise that resolves with the created annotation
      * @throws {ApiError} if the request fails
      */
-    create(fileId: string, annotation: CreateAnnotation): Promise<Annotation>;
+    createAnnotation(fileId: string, annotation: CreateAnnotation): Promise<Annotation>;
     /**
      * Update an existing annotation
      * @param annotationId - Annotation ID
@@ -152,67 +82,64 @@ declare class AnnotationsService {
      * @returns Promise that resolves with the updated annotation
      * @throws {ApiError} if the request fails
      */
-    update(annotationId: string, updates: UpdateAnnotation): Promise<Annotation>;
+    updateAnnotation(annotationId: string, updates: UpdateAnnotation): Promise<Annotation>;
     /**
      * Delete an annotation
      * @param annotationId - Annotation ID
      * @returns Promise that resolves when the annotation is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(annotationId: string): Promise<void>;
+    deleteAnnotation(annotationId: string): Promise<void>;
 }
 
 /**
  * Service for handling API token operations
  */
-declare class ApiTokensService {
+declare class ApiTokens {
     #private;
     constructor(api: ApiClient);
     /**
      * List all API tokens for the authenticated account
-     * @param options - Pagination options
-     * @returns Promise that resolves with the list of API tokens
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of API tokens
      * @throws {ApiError} if the request fails
      */
-    list(options?: {
-        offset?: number;
-        limit?: number;
-    }): Promise<ApiToken[]>;
+    listApiTokens(query?: CursorPagination): Promise<ApiTokensPage>;
     /**
-     * Get a specific API token by access token
-     * @param accessToken - The access token identifier
+     * 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
      */
-    get(accessToken: string): Promise<ApiToken>;
+    getApiToken(tokenId: string): Promise<ApiToken>;
     /**
      * Create a new API token
      * @param token - Token creation request
-     * @returns Promise that resolves with the created token (includes secret, shown only once)
+     * @returns Promise that resolves with the created token (includes JWT, shown only once)
      * @throws {ApiError} if the request fails
      */
-    create(token: CreateApiToken): Promise<ApiTokenWithSecret>;
+    createApiToken(token: CreateApiToken): Promise<ApiTokenWithJWT>;
     /**
      * Update an existing API token
-     * @param accessToken - The access token identifier
+     * @param tokenId - The token identifier
      * @param updates - Token update request
      * @returns Promise that resolves with the updated token
      * @throws {ApiError} if the request fails
      */
-    update(accessToken: string, updates: UpdateApiToken): Promise<ApiToken>;
+    updateApiToken(tokenId: string, updates: UpdateApiToken): Promise<ApiToken>;
     /**
      * Revoke an API token
-     * @param accessToken - The access token identifier
+     * @param tokenId - The token identifier
      * @returns Promise that resolves when the token is revoked
      * @throws {ApiError} if the request fails
      */
-    revoke(accessToken: string): Promise<void>;
+    revokeApiToken(tokenId: string): Promise<void>;
 }
 
 /**
  * Service for handling authentication operations
  */
-declare class AuthService {
+declare class Auth {
     #private;
     constructor(api: ApiClient);
     /**
@@ -221,30 +148,36 @@ declare class AuthService {
      * @returns Promise that resolves with the auth response containing access token
      * @throws {ApiError} if the request fails
      */
-    login(credentials: Login): Promise<AuthToken>;
+    loginAccount(credentials: Login): Promise<AuthToken>;
     /**
      * Sign up a new account
-     * @param details - Signup details
+     * @param credentials - Signup details
      * @returns Promise that resolves with the auth response containing access token
      * @throws {ApiError} if the request fails
      */
-    signup(details: Signup): Promise<AuthToken>;
+    signupAccount(credentials: Signup): Promise<AuthToken>;
+    /**
+     * Logout and invalidate the current access token
+     * @returns Promise that resolves when logout is complete
+     * @throws {ApiError} if the request fails
+     */
+    logoutAccount(): Promise<void>;
 }
 
 /**
  * Service for handling file comment operations
  */
-declare class CommentsService {
+declare class Comments {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of comments
      * @throws {ApiError} if the request fails
      */
-    list(fileId: string, query?: Pagination): Promise<Comment[]>;
+    listComments(fileId: string, query?: CursorPagination): Promise<CommentsPage>;
     /**
      * Create a new comment on a file
      * @param fileId - File ID
@@ -252,38 +185,45 @@ declare class CommentsService {
      * @returns Promise that resolves with the created comment
      * @throws {ApiError} if the request fails
      */
-    create(fileId: string, comment: CreateComment): Promise<Comment>;
+    createComment(fileId: string, comment: CreateComment): Promise<Comment>;
+    /**
+     * 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
+     */
+    updateComment(commentId: string, updates: UpdateComment): Promise<Comment>;
     /**
      * 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
      */
-    delete(fileId: string, commentId: string): Promise<void>;
+    deleteComment(commentId: string): Promise<void>;
 }
 
 /**
  * Service for handling document operations
  */
-declare class DocumentsService {
+declare class Documents {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of documents
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string, query?: Pagination): Promise<Document[]>;
+    listDocuments(workspaceId: string, query?: CursorPagination): Promise<DocumentsPage>;
     /**
      * Get document details by ID
      * @param documentId - Document ID
      * @returns Promise that resolves with the document details
      * @throws {ApiError} if the request fails
      */
-    get(documentId: string): Promise<Document>;
+    getDocument(documentId: string): Promise<Document>;
     /**
      * Create a new document
      * @param workspaceId - Workspace ID
@@ -291,7 +231,7 @@ declare class DocumentsService {
      * @returns Promise that resolves with the created document
      * @throws {ApiError} if the request fails
      */
-    create(workspaceId: string, document: CreateDocument): Promise<Document>;
+    createDocument(workspaceId: string, document: CreateDocument): Promise<Document>;
     /**
      * Update an existing document
      * @param documentId - Document ID
@@ -299,37 +239,52 @@ declare class DocumentsService {
      * @returns Promise that resolves with the updated document
      * @throws {ApiError} if the request fails
      */
-    update(documentId: string, updates: UpdateDocument): Promise<Document>;
+    updateDocument(documentId: string, updates: UpdateDocument): Promise<Document>;
     /**
      * Delete a document
      * @param documentId - Document ID
      * @returns Promise that resolves when the document is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(documentId: string): Promise<void>;
+    deleteDocument(documentId: string): Promise<void>;
 }
 
 /**
  * Service for handling file operations
  */
-declare class FilesService {
+declare class Files {
     #private;
     constructor(api: ApiClient);
+    /**
+     * 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
+     */
+    uploadFiles(workspaceId: string, files: Blob | Blob[]): Promise<File[]>;
     /**
      * 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
+     * @param query - Optional query parameters (formats, limit, after)
+     * @returns Promise that resolves with a paginated list of files
+     * @throws {ApiError} if the request fails
+     */
+    listFiles(workspaceId: string, query?: ListFiles & CursorPagination): Promise<FilesPage>;
+    /**
+     * Get file metadata by ID
+     * @param fileId - File ID
+     * @returns Promise that resolves with the file metadata
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string, query?: ListFilesQuery & Pagination): Promise<File[]>;
+    getFile(fileId: string): Promise<File>;
     /**
      * Download a file by ID
      * @param fileId - File ID
      * @returns Promise that resolves with the file response
      * @throws {ApiError} if the request fails
      */
-    download(fileId: string): Promise<Response>;
+    downloadFile(fileId: string): Promise<Response>;
     /**
      * Update a file's metadata
      * @param fileId - File ID
@@ -337,53 +292,53 @@ declare class FilesService {
      * @returns Promise that resolves with the updated file
      * @throws {ApiError} if the request fails
      */
-    update(fileId: string, updates: UpdateFile): Promise<File>;
+    updateFile(fileId: string, updates: UpdateFile): Promise<File>;
     /**
      * Delete a file
      * @param fileId - File ID
      * @returns Promise that resolves when the file is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(fileId: string): Promise<void>;
+    deleteFile(fileId: string): Promise<void>;
     /**
-     * Download multiple files
+     * Download files as an archive
      * @param workspaceId - Workspace ID
-     * @param request - Download request with file IDs
-     * @returns Promise that resolves with the download response
+     * @param request - Download request with format and optional file IDs
+     * @returns Promise that resolves with the archive response
      * @throws {ApiError} if the request fails
      */
-    downloadMultiple(workspaceId: string, request: DownloadMultipleFilesRequest): Promise<Response>;
+    downloadFiles(workspaceId: string, request: DownloadFiles): Promise<Response>;
     /**
-     * Download files as an archive
+     * Delete multiple files
      * @param workspaceId - Workspace ID
-     * @param request - Archive download request
-     * @returns Promise that resolves with the archive response
+     * @param request - Delete request with file IDs
+     * @returns Promise that resolves when the files are deleted
      * @throws {ApiError} if the request fails
      */
-    downloadArchive(workspaceId: string, request: DownloadArchivedFilesRequest): Promise<Response>;
+    deleteFiles(workspaceId: string, request: DeleteFiles): Promise<void>;
 }
 
 /**
  * Service for handling integration operations
  */
-declare class IntegrationsService {
+declare class Integrations {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of integrations
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string, query?: ListIntegrationsQuery & Pagination): Promise<Integration[]>;
+    listIntegrations(workspaceId: string, query?: CursorPagination): Promise<IntegrationsPage>;
     /**
      * Get integration details by ID
      * @param integrationId - Integration ID
      * @returns Promise that resolves with the integration details
      * @throws {ApiError} if the request fails
      */
-    get(integrationId: string): Promise<Integration>;
+    getIntegration(integrationId: string): Promise<Integration>;
     /**
      * Create a new integration
      * @param workspaceId - Workspace ID
@@ -391,7 +346,7 @@ declare class IntegrationsService {
      * @returns Promise that resolves with the created integration
      * @throws {ApiError} if the request fails
      */
-    create(workspaceId: string, integration: CreateIntegration): Promise<Integration>;
+    createIntegration(workspaceId: string, integration: CreateIntegration): Promise<Integration>;
     /**
      * Update an existing integration
      * @param integrationId - Integration ID
@@ -399,7 +354,7 @@ declare class IntegrationsService {
      * @returns Promise that resolves with the updated integration
      * @throws {ApiError} if the request fails
      */
-    update(integrationId: string, updates: UpdateIntegration): Promise<Integration>;
+    updateIntegration(integrationId: string, updates: UpdateIntegration): Promise<Integration>;
     /**
      * Update integration credentials
      * @param integrationId - Integration ID
@@ -407,30 +362,30 @@ declare class IntegrationsService {
      * @returns Promise that resolves with the updated integration
      * @throws {ApiError} if the request fails
      */
-    updateCredentials(integrationId: string, credentials: UpdateIntegrationCredentials): Promise<Integration>;
+    updateIntegrationCredentials(integrationId: string, credentials: UpdateIntegrationCredentials): Promise<Integration>;
     /**
      * Delete an integration
      * @param integrationId - Integration ID
      * @returns Promise that resolves when the integration is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(integrationId: string): Promise<void>;
+    deleteIntegration(integrationId: string): Promise<void>;
 }
 
 /**
  * Service for handling workspace invitation operations
  */
-declare class InvitesService {
+declare class Invites {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @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
      */
-    list(workspaceId: string, query?: ListInvitesQuery & Pagination): Promise<Invite[]>;
+    listInvites(workspaceId: string, query?: ListInvites & CursorPagination): Promise<InvitesPage>;
     /**
      * Send an invitation to join a workspace
      * @param workspaceId - Workspace ID
@@ -438,14 +393,14 @@ declare class InvitesService {
      * @returns Promise that resolves with the created invitation
      * @throws {ApiError} if the request fails
      */
-    send(workspaceId: string, invite: CreateInvite): Promise<Invite>;
+    sendInvite(workspaceId: string, invite: CreateInvite): Promise<Invite>;
     /**
      * Cancel a pending invitation
      * @param inviteId - Invite ID
      * @returns Promise that resolves when the invitation is canceled
      * @throws {ApiError} if the request fails
      */
-    cancel(inviteId: string): Promise<void>;
+    cancelInvite(inviteId: string): Promise<void>;
     /**
      * Reply to an invitation (accept or decline)
      * @param inviteId - Invite ID
@@ -453,7 +408,7 @@ declare class InvitesService {
      * @returns Promise that resolves with the updated invitation
      * @throws {ApiError} if the request fails
      */
-    reply(inviteId: string, reply: ReplyInvite): Promise<Invite>;
+    replyToInvite(inviteId: string, reply: ReplyInvite): Promise<Invite>;
     /**
      * Generate a shareable invite code for a workspace
      * @param workspaceId - Workspace ID
@@ -461,30 +416,38 @@ declare class InvitesService {
      * @returns Promise that resolves with the generated invite code
      * @throws {ApiError} if the request fails
      */
-    generateCode(workspaceId: string, options: GenerateInviteCode): Promise<InviteCode>;
+    generateInviteCode(workspaceId: string, options: GenerateInviteCode): Promise<InviteCode>;
     /**
-     * Join a workspace using an invite code
+     * Reply to an invite code (accept or decline)
      * @param inviteCode - The invite code
-     * @returns Promise that resolves with the member details
+     * @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
+     */
+    replyToInviteCode(inviteCode: string, reply?: ReplyInvite | null): Promise<Member | null>;
+    /**
+     * 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
      */
-    joinWithCode(inviteCode: string): Promise<Member>;
+    previewInvite(inviteCode: string): Promise<InvitePreview>;
 }
 
 /**
  * Service for handling member operations
  */
-declare class MembersService {
+declare class Members {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @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
      */
-    list(workspaceId: string, query?: ListMembersQuery & Pagination): Promise<Member[]>;
+    listMembers(workspaceId: string, query?: ListMembers & CursorPagination): Promise<MembersPage>;
     /**
      * Get member details by account ID
      * @param workspaceId - Workspace ID
@@ -492,16 +455,16 @@ declare class MembersService {
      * @returns Promise that resolves with the member details
      * @throws {ApiError} if the request fails
      */
-    get(workspaceId: string, accountId: string): Promise<Member>;
+    getMember(workspaceId: string, accountId: string): Promise<Member>;
     /**
      * Update a member's role
      * @param workspaceId - Workspace ID
      * @param accountId - Account ID
-     * @param role - New role for the member
+     * @param updates - New role for the member
      * @returns Promise that resolves with the updated member
      * @throws {ApiError} if the request fails
      */
-    updateRole(workspaceId: string, accountId: string, role: UpdateMemberRole): Promise<Member>;
+    updateMember(workspaceId: string, accountId: string, updates: UpdateMember): Promise<Member>;
     /**
      * Remove a member from a workspace
      * @param workspaceId - Workspace ID
@@ -509,58 +472,64 @@ declare class MembersService {
      * @returns Promise that resolves when the member is removed
      * @throws {ApiError} if the request fails
      */
-    remove(workspaceId: string, accountId: string): Promise<void>;
+    removeMember(workspaceId: string, accountId: string): Promise<void>;
     /**
      * Leave a workspace
      * @param workspaceId - Workspace ID
      * @returns Promise that resolves when the member has left
      * @throws {ApiError} if the request fails
      */
-    leave(workspaceId: string): Promise<void>;
+    leaveWorkspace(workspaceId: string): Promise<void>;
 }
 
 /**
  * Service for handling account notification operations
  */
-declare class NotificationsService {
+declare class Notifications {
     #private;
     constructor(api: ApiClient);
     /**
      * List notifications for the authenticated account
-     * @param query - Optional query parameters (offset, limit)
-     * @returns Promise that resolves with the list of notifications
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of notifications
      * @throws {ApiError} if the request fails
      */
-    list(query?: Pagination): Promise<Notification[]>;
+    listNotifications(query?: CursorPagination): Promise<NotificationsPage>;
+    /**
+     * Get the unread notifications count for the authenticated account
+     * @returns Promise that resolves with the unread status
+     * @throws {ApiError} if the request fails
+     */
+    getUnreadNotificationsStatus(): Promise<UnreadStatus>;
 }
 
 /**
  * Service for handling integration run operations
  */
-declare class RunsService {
+declare class Runs {
     #private;
     constructor(api: ApiClient);
     /**
      * 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
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of integration runs
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string, query?: Pagination): Promise<IntegrationRun[]>;
+    listRuns(workspaceId: string, query?: CursorPagination): Promise<IntegrationRunsPage>;
     /**
      * 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
      */
-    get(runId: string): Promise<IntegrationRun>;
+    getRun(runId: string): Promise<IntegrationRun>;
 }
 
 /**
  * Service for handling status and health check operations
  */
-declare class StatusService {
+declare class Status {
     #private;
     constructor(api: ApiClient);
     /**
@@ -568,37 +537,38 @@ declare class StatusService {
      * @param options - Health check options
      * @returns Promise that resolves with the API health status
      */
-    health(options?: CheckHealth): Promise<MonitorStatus>;
+    checkHealth(options?: CheckHealth): Promise<MonitorStatus>;
 }
 
 /**
  * Service for handling webhook operations
  */
-declare class WebhooksService {
+declare class Webhooks {
     #private;
     constructor(api: ApiClient);
     /**
      * List all webhooks in a workspace
      * @param workspaceId - Workspace ID
-     * @returns Promise that resolves with the list of webhooks
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of webhooks
      * @throws {ApiError} if the request fails
      */
-    list(workspaceId: string): Promise<Webhook[]>;
+    listWebhooks(workspaceId: string, query?: CursorPagination): Promise<WebhooksPage>;
     /**
      * Get a specific webhook by ID
      * @param webhookId - Webhook ID
      * @returns Promise that resolves with the webhook details
      * @throws {ApiError} if the request fails
      */
-    get(webhookId: string): Promise<Webhook>;
+    getWebhook(webhookId: string): Promise<Webhook>;
     /**
      * 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)
+     * @returns Promise that resolves with the created webhook
      * @throws {ApiError} if the request fails
      */
-    create(workspaceId: string, webhook: CreateWebhook): Promise<WebhookWithSecret>;
+    createWebhook(workspaceId: string, webhook: CreateWebhook): Promise<Webhook>;
     /**
      * Update an existing webhook
      * @param webhookId - Webhook ID
@@ -606,43 +576,51 @@ declare class WebhooksService {
      * @returns Promise that resolves with the updated webhook
      * @throws {ApiError} if the request fails
      */
-    update(webhookId: string, updates: UpdateWebhook): Promise<Webhook>;
+    updateWebhook(webhookId: string, updates: UpdateWebhook): Promise<Webhook>;
     /**
      * Delete a webhook
      * @param webhookId - Webhook ID
      * @returns Promise that resolves when the webhook is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(webhookId: string): Promise<void>;
+    deleteWebhook(webhookId: string): Promise<void>;
+    /**
+     * 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
+     */
+    testWebhook(webhookId: string, options?: TestWebhook): Promise<WebhookResult>;
 }
 
 /**
  * Service for handling workspace operations
  */
-declare class WorkspacesService {
+declare class Workspaces {
     #private;
     constructor(api: ApiClient);
     /**
      * List all workspaces
-     * @param query - Optional query parameters (offset, limit)
-     * @returns Promise that resolves with the list of workspaces
+     * @param query - Optional pagination parameters (limit, after)
+     * @returns Promise that resolves with a paginated list of workspaces
      * @throws {ApiError} if the request fails
      */
-    list(query?: Pagination): Promise<Workspace[]>;
+    listWorkspaces(query?: CursorPagination): Promise<WorkspacesPage>;
     /**
      * Get workspace details by ID
      * @param workspaceId - Workspace ID
      * @returns Promise that resolves with the workspace details
      * @throws {ApiError} if the request fails
      */
-    get(workspaceId: string): Promise<Workspace>;
+    getWorkspace(workspaceId: string): Promise<Workspace>;
     /**
      * Create a new workspace
      * @param workspace - Workspace creation request
      * @returns Promise that resolves with the created workspace
      * @throws {ApiError} if the request fails
      */
-    create(workspace: CreateWorkspace): Promise<Workspace>;
+    createWorkspace(workspace: CreateWorkspace): Promise<Workspace>;
     /**
      * Update an existing workspace
      * @param workspaceId - Workspace ID
@@ -650,28 +628,43 @@ declare class WorkspacesService {
      * @returns Promise that resolves with the updated workspace
      * @throws {ApiError} if the request fails
      */
-    update(workspaceId: string, updates: UpdateWorkspace): Promise<Workspace>;
+    updateWorkspace(workspaceId: string, updates: UpdateWorkspace): Promise<Workspace>;
     /**
      * Delete a workspace
      * @param workspaceId - Workspace ID
      * @returns Promise that resolves when the workspace is deleted
      * @throws {ApiError} if the request fails
      */
-    delete(workspaceId: string): Promise<void>;
+    deleteWorkspace(workspaceId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getNotificationSettings(workspaceId: string): Promise<NotificationSettings>;
+    /**
+     * 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
+     */
+    updateNotificationSettings(workspaceId: string, settings: UpdateNotificationSettings): Promise<NotificationSettings>;
 }
 
 /**
  * @fileoverview Main client for the Nvisy SDK.
  *
- * This module exports the {@link Client} class, which is the primary entry point
+ * This module exports the {@link Nvisy} class, which is the primary entry point
  * for interacting with the Nvisy document processing API.
  *
  * @module client
  *
  * @example
  * ```typescript
- * const client = new Client({ apiToken: "your-api-token" });
- * const account = await client.account.get();
+ * const nvisy = new Nvisy({ apiToken: "your-api-token" });
+ * const account = await nvisy.account.getAccount();
  * ```
  */
 
@@ -679,34 +672,34 @@ declare class WorkspacesService {
  * Typed openapi-fetch client for the Nvisy API.
  *
  * This type represents the low-level HTTP client configured with the Nvisy API schema.
- * It's exposed via {@link Client.api} for advanced use cases requiring direct API access.
+ * It's exposed via {@link Nvisy.api} for advanced use cases requiring direct API access.
  */
-type ApiClient = Client$1<paths>;
+type ApiClient = Client<paths>;
 /**
  * Main client class for interacting with the Nvisy document processing API.
  *
  * @example
  * ```typescript
- * const client = new Client({ apiToken: "your-api-token" });
- * const account = await client.account.get();
- * const workspaces = await client.workspaces.list();
+ * const nvisy = new Nvisy({ apiToken: "your-api-token" });
+ * const account = await nvisy.account.getAccount();
+ * const workspaces = await nvisy.workspaces.listWorkspaces();
  * ```
  */
-declare class Client {
+declare class Nvisy {
     #private;
     /**
      * Creates a new Nvisy client instance.
      *
      * @param config - Configuration options with required `apiToken`
-     * @throws {ConfigError} If the API token is invalid
+     * @throws {NvisyError} If the API token is invalid
      *
      * @example
      * ```typescript
-     * const client = new Client({
+     * const nvisy = new Nvisy({
      *   apiToken: "your-api-token",
      *   baseUrl: "https://custom.api.nvisy.com",
      * });
-     * const account = await client.account.get();
+     * const account = await nvisy.account.getAccount();
      * ```
      */
     constructor(config: ClientConfig);
@@ -718,19 +711,19 @@ declare class Client {
      * is preserved in the new client.
      *
      * @param apiToken - The new API token
-     * @returns A new Client instance with the new token
-     * @throws {ConfigError} If the API token is invalid
+     * @returns A new Nvisy instance with the new token
+     * @throws {NvisyError} If the API token is invalid
      *
      * @example
      * ```typescript
-     * const client = new Client({ apiToken: "original-token" });
-     * const newClient = client.withApiToken("new-token");
+     * const nvisy = new Nvisy({ apiToken: "original-token" });
+     * const newNvisy = nvisy.withApiToken("new-token");
      *
-     * // newClient uses the new token
-     * // client still uses the original token
+     * // newNvisy uses the new token
+     * // nvisy still uses the original token
      * ```
      */
-    withApiToken(apiToken: string): Client;
+    withApiToken(apiToken: string): Nvisy;
     /**
      * The base URL used for API requests.
      *
@@ -748,76 +741,68 @@ declare class Client {
     get api(): ApiClient;
     /**
      * Service for authentication operations (login, signup, logout).
-     *
-     * @returns The AuthService instance
      */
-    get auth(): AuthService;
+    get auth(): Auth;
     /**
      * Service for API status and health checks.
-     *
-     * @returns The StatusService instance
      */
-    get status(): StatusService;
+    get status(): Status;
     /**
      * Service for managing the authenticated user's account.
-     *
-     * @returns The AccountService instance
      */
-    get account(): AccountService;
+    get account(): Account;
+    /**
+     * Service for viewing workspace activities.
+     */
+    get activities(): Activities;
+    /**
+     * Service for managing file annotations.
+     */
+    get annotations(): Annotations;
     /**
      * Service for managing API tokens.
-     *
-     * @returns The ApiTokensService instance
      */
-    get apiTokens(): ApiTokensService;
+    get apiTokens(): ApiTokens;
     /**
      * Service for managing file comments.
-     *
-     * @returns The CommentsService instance
      */
-    get comments(): CommentsService;
+    get comments(): Comments;
     /**
      * Service for document operations.
-     *
-     * @returns The DocumentsService instance
      */
-    get documents(): DocumentsService;
+    get documents(): Documents;
     /**
      * Service for file operations (upload, download, delete).
-     *
-     * @returns The FilesService instance
      */
-    get files(): FilesService;
+    get files(): Files;
     /**
      * Service for managing integrations.
-     *
-     * @returns The IntegrationsService instance
      */
-    get integrations(): IntegrationsService;
+    get integrations(): Integrations;
     /**
      * Service for managing workspace invitations.
-     *
-     * @returns The InvitesService instance
      */
-    get invites(): InvitesService;
+    get invites(): Invites;
     /**
      * Service for managing workspace members.
-     *
-     * @returns The MembersService instance
      */
-    get members(): MembersService;
+    get members(): Members;
+    /**
+     * Service for managing notifications.
+     */
+    get notifications(): Notifications;
+    /**
+     * Service for managing processing runs.
+     */
+    get runs(): Runs;
     /**
      * Service for managing webhooks.
-     *
-     * @returns The WebhooksService instance
      */
-    get webhooks(): WebhooksService;
+    get webhooks(): Webhooks;
     /**
      * Service for managing workspaces.
-     *
-     * @returns The WorkspacesService instance
      */
-    get workspaces(): WorkspacesService;
+    get workspaces(): Workspaces;
 }
 
-export { type ApiClient as A, Client as C, DEFAULTS as D, FilesService as F, IntegrationsService as I, MembersService as M, NotificationsService as N, RunsService as R, StatusService as S, VERSION as V, WebhooksService as W, type ClientConfig as a, AccountService as b, ActivitiesService as c, AnnotationsService as d, ApiTokensService as e, AuthService as f, CommentsService as g, DocumentsService as h, InvitesService as i, WorkspacesService as j };
+export { type ApiClient as A, Comments as C, Documents as D, Files as F, Integrations as I, Members as M, Nvisy as N, Runs as R, Status as S, Webhooks as W, Account as a, Activities as b, Annotations as c, ApiTokens as d, Auth as e, Invites as f, Notifications as g, Workspaces as h };