@nvisy/sdk 0.2.0 → 0.4.0

package/dist/services-Dh0FMDzU.js

@@ -0,0 +1,1040 @@
+//#region src/services/account.ts
+/**
+* Service for handling account operations
+*/
+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/");
+	}
+};
+
+//#endregion
+//#region src/services/activities.ts
+/**
+* Service for handling workspace activity operations
+*/
+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;
+	}
+};
+
+//#endregion
+//#region src/services/api-tokens.ts
+/**
+* Service for handling API token operations
+*/
+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 } } });
+	}
+};
+
+//#endregion
+//#region src/services/auth.ts
+/**
+* Service for handling authentication operations
+*/
+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/");
+	}
+};
+
+//#endregion
+//#region src/services/connections.ts
+/**
+* Service for handling connection operations
+*/
+var Connections = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List connections in a workspace
+	* @param workspaceId - Workspace ID
+	* @param query - Optional query parameters (provider, limit, after)
+	* @returns Promise that resolves with a paginated list of connections
+	* @throws {ApiError} if the request fails
+	*/
+	async listConnections(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/connections/", { params: {
+			path: { workspaceId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Create a connection in a workspace
+	* @param workspaceId - Workspace ID
+	* @param connection - Connection creation request
+	* @returns Promise that resolves with the created connection
+	* @throws {ApiError} if the request fails
+	*/
+	async createConnection(workspaceId, connection) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/connections/", {
+			params: { path: { workspaceId } },
+			body: connection
+		});
+		return data;
+	}
+	/**
+	* Get connection details by ID
+	* @param connectionId - Connection ID
+	* @returns Promise that resolves with the connection details
+	* @throws {ApiError} if the request fails
+	*/
+	async getConnection(connectionId) {
+		const { data } = await this.#api.GET("/connections/{connectionId}/", { params: { path: { connectionId } } });
+		return data;
+	}
+	/**
+	* Update a connection
+	* @param connectionId - Connection ID
+	* @param updates - Connection update request
+	* @returns Promise that resolves with the updated connection
+	* @throws {ApiError} if the request fails
+	*/
+	async updateConnection(connectionId, updates) {
+		const { data } = await this.#api.PUT("/connections/{connectionId}/", {
+			params: { path: { connectionId } },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a connection
+	* @param connectionId - Connection ID
+	* @returns Promise that resolves when the connection is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deleteConnection(connectionId) {
+		await this.#api.DELETE("/connections/{connectionId}/", { params: { path: { connectionId } } });
+	}
+};
+
+//#endregion
+//#region src/services/contexts.ts
+/**
+* Service for handling context operations
+*/
+var Contexts = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List contexts in a workspace
+	* @param workspaceId - Workspace ID
+	* @param query - Optional pagination parameters (limit, after)
+	* @returns Promise that resolves with a paginated list of contexts
+	* @throws {ApiError} if the request fails
+	*/
+	async listContexts(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/contexts/", { params: {
+			path: { workspaceId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Create a context in a workspace
+	* @param workspaceId - Workspace ID
+	* @param context - Context creation request
+	* @returns Promise that resolves with the created context
+	* @throws {ApiError} if the request fails
+	*/
+	async createContext(workspaceId, context) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/contexts/", {
+			params: { path: { workspaceId } },
+			body: context
+		});
+		return data;
+	}
+	/**
+	* Get context details by ID
+	* @param contextId - Context ID
+	* @returns Promise that resolves with the context details
+	* @throws {ApiError} if the request fails
+	*/
+	async getContext(contextId) {
+		const { data } = await this.#api.GET("/contexts/{contextId}/", { params: { path: { contextId } } });
+		return data;
+	}
+	/**
+	* Update a context
+	* @param contextId - Context ID
+	* @param updates - Context update request
+	* @returns Promise that resolves with the updated context
+	* @throws {ApiError} if the request fails
+	*/
+	async updateContext(contextId, updates) {
+		const { data } = await this.#api.PUT("/contexts/{contextId}/", {
+			params: { path: { contextId } },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a context
+	* @param contextId - Context ID
+	* @returns Promise that resolves when the context is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deleteContext(contextId) {
+		await this.#api.DELETE("/contexts/{contextId}/", { params: { path: { contextId } } });
+	}
+};
+
+//#endregion
+//#region src/services/files.ts
+/**
+* Service for handling file operations
+*/
+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 } },
+			body: formData,
+			bodySerializer: (formData) => formData,
+			headers: { "Content-Type": null }
+		});
+		return data;
+	}
+	/**
+	* List files in a workspace
+	* @param workspaceId - Workspace ID
+	* @param query - Optional query parameters (formats, search, 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 } } });
+	}
+};
+
+//#endregion
+//#region src/services/invites.ts
+/**
+* Service for handling workspace invitation operations
+*/
+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;
+	}
+};
+
+//#endregion
+//#region src/services/members.ts
+/**
+* Service for handling member operations
+*/
+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}/", {
+			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 } } });
+	}
+};
+
+//#endregion
+//#region src/services/notifications.ts
+/**
+* Service for handling account notification operations
+*/
+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;
+	}
+};
+
+//#endregion
+//#region src/services/pipelines.ts
+/**
+* Service for handling pipeline operations
+*/
+var Pipelines = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List pipelines in a workspace
+	* @param workspaceId - Workspace ID
+	* @param query - Optional query parameters (search, status, limit, after)
+	* @returns Promise that resolves with a paginated list of pipeline summaries
+	* @throws {ApiError} if the request fails
+	*/
+	async listPipelines(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/pipelines/", { params: {
+			path: { workspaceId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Create a pipeline in a workspace
+	* @param workspaceId - Workspace ID
+	* @param pipeline - Pipeline creation request
+	* @returns Promise that resolves with the created pipeline
+	* @throws {ApiError} if the request fails
+	*/
+	async createPipeline(workspaceId, pipeline) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/pipelines/", {
+			params: { path: { workspaceId } },
+			body: pipeline
+		});
+		return data;
+	}
+	/**
+	* Get pipeline details by ID
+	* @param pipelineId - Pipeline ID
+	* @returns Promise that resolves with the pipeline details
+	* @throws {ApiError} if the request fails
+	*/
+	async getPipeline(pipelineId) {
+		const { data } = await this.#api.GET("/pipelines/{pipelineId}/", { params: { path: { pipelineId } } });
+		return data;
+	}
+	/**
+	* Update a pipeline
+	* @param pipelineId - Pipeline ID
+	* @param updates - Pipeline update request
+	* @returns Promise that resolves with the updated pipeline
+	* @throws {ApiError} if the request fails
+	*/
+	async updatePipeline(pipelineId, updates) {
+		const { data } = await this.#api.PATCH("/pipelines/{pipelineId}/", {
+			params: { path: { pipelineId } },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a pipeline
+	* @param pipelineId - Pipeline ID
+	* @returns Promise that resolves when the pipeline is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deletePipeline(pipelineId) {
+		await this.#api.DELETE("/pipelines/{pipelineId}/", { params: { path: { pipelineId } } });
+	}
+};
+
+//#endregion
+//#region src/services/policies.ts
+/**
+* Service for handling policy operations
+*/
+var Policies = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List policies in a workspace
+	* @param workspaceId - Workspace ID
+	* @param query - Optional pagination parameters (limit, after)
+	* @returns Promise that resolves with a paginated list of policies
+	* @throws {ApiError} if the request fails
+	*/
+	async listPolicies(workspaceId, query) {
+		const { data } = await this.#api.GET("/workspaces/{workspaceId}/policies/", { params: {
+			path: { workspaceId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Create a policy in a workspace
+	* @param workspaceId - Workspace ID
+	* @param policy - Policy creation request
+	* @returns Promise that resolves with the created policy
+	* @throws {ApiError} if the request fails
+	*/
+	async createPolicy(workspaceId, policy) {
+		const { data } = await this.#api.POST("/workspaces/{workspaceId}/policies/", {
+			params: { path: { workspaceId } },
+			body: policy
+		});
+		return data;
+	}
+	/**
+	* Get policy details by ID
+	* @param policyId - Policy ID
+	* @returns Promise that resolves with the policy details
+	* @throws {ApiError} if the request fails
+	*/
+	async getPolicy(policyId) {
+		const { data } = await this.#api.GET("/policies/{policyId}/", { params: { path: { policyId } } });
+		return data;
+	}
+	/**
+	* Update a policy
+	* @param policyId - Policy ID
+	* @param updates - Policy update request
+	* @returns Promise that resolves with the updated policy
+	* @throws {ApiError} if the request fails
+	*/
+	async updatePolicy(policyId, updates) {
+		const { data } = await this.#api.PUT("/policies/{policyId}/", {
+			params: { path: { policyId } },
+			body: updates
+		});
+		return data;
+	}
+	/**
+	* Delete a policy
+	* @param policyId - Policy ID
+	* @returns Promise that resolves when the policy is deleted
+	* @throws {ApiError} if the request fails
+	*/
+	async deletePolicy(policyId) {
+		await this.#api.DELETE("/policies/{policyId}/", { params: { path: { policyId } } });
+	}
+};
+
+//#endregion
+//#region src/services/runs.ts
+/**
+* Service for handling pipeline run operations
+*/
+var Runs = class {
+	#api;
+	constructor(api) {
+		this.#api = api;
+	}
+	/**
+	* List runs for a pipeline
+	* @param pipelineId - Pipeline ID
+	* @param query - Optional pagination parameters (limit, after)
+	* @returns Promise that resolves with a paginated list of pipeline runs
+	* @throws {ApiError} if the request fails
+	*/
+	async listRuns(pipelineId, query) {
+		const { data } = await this.#api.GET("/pipelines/{pipelineId}/runs/", { params: {
+			path: { pipelineId },
+			query
+		} });
+		return data;
+	}
+	/**
+	* Trigger a new run for a pipeline
+	* @param pipelineId - Pipeline ID
+	* @param run - Pipeline run creation request
+	* @returns Promise that resolves with the created pipeline run
+	* @throws {ApiError} if the request fails
+	*/
+	async createRun(pipelineId, run) {
+		const { data } = await this.#api.POST("/pipelines/{pipelineId}/runs/", {
+			params: { path: { pipelineId } },
+			body: run
+		});
+		return data;
+	}
+	/**
+	* Get pipeline run details by ID
+	* @param runId - Run ID
+	* @returns Promise that resolves with the pipeline run details
+	* @throws {ApiError} if the request fails
+	*/
+	async getRun(runId) {
+		const { data } = await this.#api.GET("/runs/{runId}/", { params: { path: { runId } } });
+		return data;
+	}
+	/**
+	* Get the detections (analyzed document) for a pipeline run
+	* @param runId - Run ID
+	* @returns Promise that resolves with the analyzed document
+	* @throws {ApiError} if the request fails
+	*/
+	async getDetections(runId) {
+		const { data } = await this.#api.GET("/runs/{runId}/detections/", { params: { path: { runId } } });
+		return data;
+	}
+	/**
+	* Apply redactions to a pipeline run
+	* @param runId - Run ID
+	* @returns Promise that resolves with the updated pipeline run
+	* @throws {ApiError} if the request fails
+	*/
+	async redact(runId) {
+		const { data } = await this.#api.POST("/runs/{runId}/redactions/", { params: { path: { runId } } });
+		return data;
+	}
+};
+
+//#endregion
+//#region src/services/status.ts
+/**
+* Service for handling status and health check operations
+*/
+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;
+	}
+};
+
+//#endregion
+//#region src/services/webhooks.ts
+/**
+* Service for handling webhook operations
+*/
+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;
+	}
+};
+
+//#endregion
+//#region src/services/workspaces.ts
+/**
+* Service for handling workspace operations
+*/
+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;
+	}
+};
+
+//#endregion
+export { Policies as a, Members as c, Contexts as d, Connections as f, Account as g, Activities as h, Runs as i, Invites as l, ApiTokens as m, Webhooks as n, Pipelines as o, Auth as p, Status as r, Notifications as s, Workspaces as t, Files as u };
+//# sourceMappingURL=services-Dh0FMDzU.js.map