@egose/n8n-client 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,4 +1,24 @@
-## [0.1.1](https://github.com/egose/n8n-client/compare/v0.1.0...v0.1.1) (2026-06-11)
+## [0.2.0](https://github.com/egose/n8n-client/compare/v0.1.2...v0.2.0) (2026-06-13)
+
+### Features
+
+* **website:** add bound resource clients and resource helpers across website API ([06929b2](https://github.com/egose/n8n-client/commit/06929b242b5bca3d81b2a2ffc5b3a54dca127121))
+* **website:** rename resource handles to clients and update factory methods ([cd551cc](https://github.com/egose/n8n-client/commit/cd551cc860cbc0ee3a1b8fbb28985a56704f0c77))
+
+### Docs
+
+* **website:** document raw versus resource client usage patterns ([1015838](https://github.com/egose/n8n-client/commit/101583834502dd253d705dc5dcad55c4ad68d9d8))
+* **website:** refresh website docs and examples for client naming ([bf646e5](https://github.com/egose/n8n-client/commit/bf646e51b3c95f3e7a94414a8196e1336e2f9037))
+
+## [0.1.2](https://github.com/egose/n8n-client/compare/v0.1.1...v0.1.2) (2026-06-13)
+
+### Docs
+
+* **website:** update api reference and project documentation ([8eb8e1d](https://github.com/egose/n8n-client/commit/8eb8e1dab71a2cf077cf35dc3d88c8b1f580f3cd))
+
+### Refactors
+
+* **website:** introduce base handle and refine api types ([33202cf](https://github.com/egose/n8n-client/commit/33202cf3bf58a4c3b0d80df81079fe14bcab4fda))
 
 ## [0.1.0](https://github.com/egose/n8n-client/compare/af6753477e8559b1324897e2af7f99772846a4a2...v0.1.0) (2026-06-11)
 

package/README.md

@@ -12,7 +12,7 @@
 </p>
 
 <p align="center">
-  TypeScript client for the n8n Public API with cursor-based pagination and typed resource handles.
+  TypeScript client for the n8n Public API with cursor-based pagination and typed resource clients.
 </p>
 
 <p align="center">
@@ -25,14 +25,14 @@
 
 ## What It Is
 
-`@egose/n8n-client` provides a TypeScript client for the [n8n Public API](https://docs.n8n.io/api/). Instead of manually constructing HTTP requests and parsing responses, you work through resource handles:
+`@egose/n8n-client` provides a TypeScript client for the [n8n Public API](https://docs.n8n.io/api/). Instead of manually constructing HTTP requests and parsing responses, you work through resource clients:
 
 ```ts
 const client = new N8nClient({ baseUrl: 'http://localhost:5678', apiKey: 'your-api-key' }); // pragma: allowlist secret
 
-const workflows = await client.workflow().list({ limit: 10 });
-const workflow = await client.workflow().get('wf-1');
-const executions = await client.execution().list({ workflowId: 'wf-1', status: 'success' });
+const workflows = await client.workflows().list({ limit: 10 });
+const workflow = await client.workflows().get('wf-1');
+const executions = await client.executions().list({ workflowId: 'wf-1', status: 'success' });
 ```
 
 ## Why Use It
@@ -40,7 +40,7 @@ const executions = await client.execution().list({ workflowId: 'wf-1', status: '
 - Typed request/response objects for all n8n API endpoints
 - Cursor-based pagination built in
 - Automatic retry on transient server errors (5xx, 429, 408)
-- Consistent resource handle pattern across all resource types
+- Consistent resource client pattern across all resource types
 - Supports both API key and Bearer token authentication
 
 ## Installation
@@ -64,38 +64,46 @@ const client = new N8nClient({
 });
 
 // List workflows
-const { data: workflows, nextCursor } = await client.workflow().list({ limit: 10 });
+const { data: workflows, nextCursor } = await client.workflows().list({ limit: 10 });
 
 // Create a workflow
-const workflow = await client.workflow().create({
+const workflow = await client.workflows().create({
   name: 'My Workflow',
   nodes: [{ name: 'Start', type: 'n8n-nodes-base.start', position: [250, 300] }],
   connections: {},
+  settings: {},
 });
 
 // Activate it
-await client.workflow().activate(workflow.id);
+await client.workflows().activate(workflow.id);
 
 // List executions
-const { data: executions } = await client.execution().list({ workflowId: workflow.id });
+const { data: executions } = await client.executions().list({ workflowId: workflow.id });
 
 // Create a credential
-const credential = await client.credential().create({
+const credential = await client.credentials().create({
   name: 'My GitHub Token',
   type: 'githubApi',
   data: { accessToken: 'ghp_xxx' },
 });
 
 // Test the credential
-const testResult = await client.credential().test(credential.id);
+const testResult = await client.credentials().test(credential.id);
 
 // Manage tags
-const tag = await client.tag().create({ name: 'production' });
-await client.workflow().updateTags(workflow.id, [{ id: tag.id }]);
+const tag = await client.tags().create({ name: 'production' });
+await client.workflows().updateTags(workflow.id, [{ id: tag.id }]);
 
 // Manage projects
-const projects = await client.project().list();
-await client.project().addMembers(projects.data[0].id, [{ userId: 'user-1', role: 'project:editor' }]);
+const projects = await client.projects().list();
+await client.projects().addMembers(projects.data[0].id, [{ userId: 'user-1', role: 'project:editor' }]);
+
+// Opt into bound resource objects when you want instance methods
+const project = await client.projects().getResource(projects.data[0].id);
+await project.update({ name: 'Production' });
+
+const workflow = await client.workflows().getResource('wf-1');
+await workflow.activate();
 
 // Insights
 const summary = await client.insights().getSummary({
@@ -126,12 +134,131 @@ const client = new N8nClient({
 });
 ```
 
-## Resource Handles
+## Resource Clients
+
+Raw collection methods like `list()` and `get()` return plain API response objects.
+
+Opt into bound resource objects when you want instance methods:
+
+```ts
+const project = await client.projects().getResource('proj-1');
+await project.update({ name: 'Ops' });
+
+const workflows = await project.workflows().listResources();
+await workflows.data[0]?.archive();
+
+const folders = await project.folders().listResources({ take: '10' });
+await folders.data[0]?.update({ name: 'Archived Workflows' });
+
+const renamedFolder = await project.folders().updateResource('folder-id', { name: 'Archived Workflows' });
+
+await project.variables().create({ key: 'API_URL', value: 'https://example.com' });
+
+const createdWorkflow = await project.workflows().create({
+  name: 'Sync',
+  nodes: [],
+  connections: {},
+  settings: {},
+});
+
+const createdFolder = await project.folders().create({ name: 'Operations' });
+
+const table = await project.dataTables().createResource({
+  name: 'Users',
+  columns: [{ name: 'email', type: 'string' }],
+});
+
+await table.createColumn({ name: 'active', type: 'boolean' });
+
+const recentRuns = await project.executions().listResources({ limit: 10, status: 'success' });
+await recentRuns.data[0]?.getTags();
+
+const workflowResource = await client.workflows().getResource('wf-1');
+const workflowRuns = await workflowResource.executions().listResources({ limit: 10 });
+```
+
+Nested collections follow the same pairing pattern when the API can support it:
+
+```ts
+const rawWorkflow = await project.workflows().get('wf-1');
+const workflowResource = await project.workflows().getResource('wf-1');
+
+const rawFolder = await project.folders().update('folder-id', { name: 'Archive' });
+const folderResource = await project.folders().updateResource('folder-id', { name: 'Archive' });
+```
+
+The same rule applies at the top-level clients: use `get()` for raw API objects and `getResource()` for bound instances.
+
+The current resource layer covers projects, workflows, credentials, folders, tags, and users:
+
+```ts
+const credential = await client.credentials().getResource('cred-1');
+await credential.test();
+
+const folder = await client.folders('proj-1').getResource('folder-1');
+await folder.update({ name: 'Archived Workflows' });
+
+const user = await client.users().getResource('user-1', { includeRole: true });
+await user.changeRole('global:admin');
+```
+
+It also includes resources for executions, variables, and data tables:
+
+```ts
+const execution = await client.executions().getResource(42, { includeData: true });
+await execution.stop();
+
+const variable = await client.variables().getResource('var-1');
+await variable.update({ key: 'API_URL', value: 'https://example.com' });
+
+const dataTable = await client.dataTables().createResource({
+  name: 'Users',
+  columns: [{ name: 'email', type: 'string' }],
+});
+
+await dataTable.createColumn({ name: 'active', type: 'boolean' });
+```
+
+Community packages use install/uninstall terminology instead of create/delete:
+
+```ts
+const pkg = await client.communityPackages().installResource({
+  name: 'n8n-nodes-foo',
+});
+
+await pkg.update({ version: '2.0.0' });
+await pkg.uninstall();
+```
+
+When the create endpoint returns the created entity, the client also exposes `createResource()`:
+
+```ts
+const workflow = await client.workflows().createResource({
+  name: 'Sync',
+  nodes: [],
+  connections: {},
+  settings: {},
+});
+
+const credential = await client.credentials().createResource({
+  name: 'Internal API Token',
+  type: 'httpHeaderAuth',
+  data: { name: 'Authorization', value: 'Bearer token' },
+});
+```
+
+Rule of thumb:
+
+- `create()` mirrors the underlying API/client return type
+- `createResource()` returns a bound resource instance when the API returns the created entity
+- `updateResource()` returns a bound resource instance when the updated result can be represented honestly, either from the update response itself or from a verified follow-up fetch
+
+`projects().createResource()` is intentionally not available because `POST /projects` returns no entity or identifier.
 
 ### Workflow
 
 ```ts
-const workflowApi = client.workflow();
+const workflowApi = client.workflows();
 
 // List with filters
 const { data, nextCursor } = await workflowApi.list({
@@ -144,8 +271,15 @@ const { data, nextCursor } = await workflowApi.list({
 
 // CRUD
 const workflow = await workflowApi.get('wf-1');
-const created = await workflowApi.create({ name: 'New', nodes: [], connections: {} });
+const workflowResource = await workflowApi.getResource('wf-1');
+const created = await workflowApi.create({ name: 'New', nodes: [], connections: {}, settings: {} });
 const updated = await workflowApi.update('wf-1', { name: 'Updated' });
+const updatedResource = await workflowApi.updateResource('wf-1', {
+  name: 'Updated Again',
+  nodes: [],
+  connections: {},
+  settings: {},
+});
 await workflowApi.delete('wf-1');
 
 // Actions
@@ -161,12 +295,15 @@ await workflowApi.updateTags('wf-1', [{ id: 'tag-1' }]);
 
 // Versioning
 const version = await workflowApi.getVersion('wf-1', 'v-1');
+
+// Nested executions
+const runs = await workflowResource.executions().listResources({ limit: 10 });
 ```
 
 ### Execution
 
 ```ts
-const executionApi = client.execution();
+const executionApi = client.executions();
 
 const { data } = await executionApi.list({ status: 'success', workflowId: 'wf-1' });
 const execution = await executionApi.get(1, { includeData: true });
@@ -182,7 +319,7 @@ await executionApi.updateTags(1, [{ id: 'tag-1' }]);
 ### Credential
 
 ```ts
-const credentialApi = client.credential();
+const credentialApi = client.credentials();
 
 const { data } = await credentialApi.list({ limit: 10 });
 const credential = await credentialApi.get('c-1');
@@ -192,6 +329,7 @@ const created = await credentialApi.create({
   data: { accessToken: 'ghp_xxx' },
 });
 const updated = await credentialApi.update('c-1', { name: 'GitHub Updated' });
+const updatedResource = await credentialApi.updateResource('c-1', { name: 'GitHub Updated Again' });
 await credentialApi.delete('c-1');
 await credentialApi.test('c-1');
 await credentialApi.transfer('c-1', 'proj-2');
@@ -201,19 +339,20 @@ const schema = await credentialApi.getSchema('githubApi');
 ### Tag
 
 ```ts
-const tagApi = client.tag();
+const tagApi = client.tags();
 
 const { data } = await tagApi.list({ limit: 10 });
 const tag = await tagApi.get('t-1');
 const created = await tagApi.create({ name: 'production' });
 const updated = await tagApi.update('t-1', { name: 'prod' });
+const updatedResource = await tagApi.updateResource('t-1', { name: 'production' });
 await tagApi.delete('t-1');
 ```
 
 ### User
 
 ```ts
-const userApi = client.user();
+const userApi = client.users();
 
 const { data } = await userApi.list({ limit: 10 });
 const user = await userApi.get('u-1');
@@ -225,7 +364,7 @@ await userApi.changeRole('u-1', 'global:admin');
 ### Variable
 
 ```ts
-const variableApi = client.variable();
+const variableApi = client.variables();
 
 const { data } = await variableApi.list({ projectId: 'proj-1' });
 await variableApi.create({ key: 'MY_VAR', value: 'hello', projectId: 'proj-1' });
@@ -236,7 +375,7 @@ await variableApi.delete('v-1');
 ### Project
 
 ```ts
-const projectApi = client.project();
+const projectApi = client.projects();
 
 const { data } = await projectApi.list({ limit: 10 });
 await projectApi.create({ name: 'New Project' });
@@ -253,7 +392,7 @@ await projectApi.removeMember('p-1', 'u-1');
 ### DataTable
 
 ```ts
-const dataTableApi = client.dataTable();
+const dataTableApi = client.dataTables();
 
 const { data } = await dataTableApi.list({ limit: 10 });
 const table = await dataTableApi.get('dt-1');
@@ -265,6 +404,7 @@ const created = await dataTableApi.create({
   ],
 });
 await dataTableApi.update('dt-1', { name: 'Users Updated' });
+const updatedTable = await dataTableApi.updateResource('dt-1', { name: 'Users Final' });
 await dataTableApi.delete('dt-1');
 
 // Rows
@@ -281,23 +421,25 @@ await dataTableApi.deleteColumn('dt-1', 'col-1');
 ### Folder
 
 ```ts
-const folderApi = client.folder('proj-1');
+const folderApi = client.folders('proj-1');
 
 const { data } = await folderApi.list({ take: '10' });
 const folder = await folderApi.get('f-1');
 const created = await folderApi.create({ name: 'My Folder' });
 const updated = await folderApi.update('f-1', { name: 'Renamed' });
+const updatedResource = await folderApi.updateResource('f-1', { name: 'Renamed Again' });
 await folderApi.delete('f-1', 'f-2'); // transfer contents to f-2
 ```
 
 ### Community Package
 
 ```ts
-const pkgApi = client.communityPackage();
+const pkgApi = client.communityPackages();
 
 const packages = await pkgApi.list();
 const installed = await pkgApi.install({ name: 'n8n-nodes-foo' });
 await pkgApi.update('n8n-nodes-foo', { version: '2.0.0' });
+const updatedResource = await pkgApi.updateResource('n8n-nodes-foo', { version: '2.1.0' });
 await pkgApi.uninstall('n8n-nodes-foo');
 ```
 
@@ -340,7 +482,7 @@ const capabilities = await client.discover().get({ include: 'schemas' });
 import { HttpError } from '@egose/n8n-client';
 
 try {
-  await client.workflow().get('nonexistent');
+  await client.workflows().get('nonexistent');
 } catch (error) {
   if (error instanceof HttpError) {
     console.log(error.status); // 404
@@ -356,23 +498,23 @@ Transient errors (408, 429, 5xx) are automatically retried up to 3 times with ex
 
 ### N8nClient
 
-| Method               | Returns                  | Description                                      |
-| -------------------- | ------------------------ | ------------------------------------------------ |
-| `workflow()`         | `WorkflowHandle`         | Workflow CRUD + activate/deactivate/archive/tags |
-| `execution()`        | `ExecutionHandle`        | Execution list/get/delete/retry/stop/tags        |
-| `credential()`       | `CredentialHandle`       | Credential CRUD + test/transfer/schema           |
-| `tag()`              | `TagHandle`              | Tag CRUD                                         |
-| `user()`             | `UserHandle`             | User list/get/create/delete/changeRole           |
-| `variable()`         | `VariableHandle`         | Variable CRUD                                    |
-| `project()`          | `ProjectHandle`          | Project CRUD + member management                 |
-| `dataTable()`        | `DataTableHandle`        | DataTable CRUD + rows/columns                    |
-| `folder(projectId)`  | `FolderHandle`           | Folder CRUD scoped to project                    |
-| `communityPackage()` | `CommunityPackageHandle` | Package install/update/uninstall                 |
-| `audit()`            | `AuditHandle`            | Generate security audit                          |
-| `insights()`         | `InsightsHandle`         | Execution insights summary                       |
-| `sourceControl()`    | `SourceControlHandle`    | Git-based source control pull                    |
-| `discover()`         | `DiscoverHandle`         | API capability discovery                         |
-| `n8nPackage()`       | `N8nPackageHandle`       | Package export/import (beta)                     |
+| Method                | Returns                  | Description                                      |
+| --------------------- | ------------------------ | ------------------------------------------------ |
+| `workflows()`         | `WorkflowClient`         | Workflow CRUD + activate/deactivate/archive/tags |
+| `executions()`        | `ExecutionClient`        | Execution list/get/delete/retry/stop/tags        |
+| `credentials()`       | `CredentialClient`       | Credential CRUD + test/transfer/schema           |
+| `tags()`              | `TagClient`              | Tag CRUD                                         |
+| `users()`             | `UserClient`             | User list/get/create/delete/changeRole           |
+| `variables()`         | `VariableClient`         | Variable CRUD                                    |
+| `projects()`          | `ProjectClient`          | Project CRUD + member management                 |
+| `dataTables()`        | `DataTableClient`        | DataTable CRUD + rows/columns                    |
+| `folders(projectId)`  | `FolderClient`           | Folder CRUD scoped to project                    |
+| `communityPackages()` | `CommunityPackageClient` | Package install/update/uninstall                 |
+| `audit()`             | `AuditClient`            | Generate security audit                          |
+| `insights()`          | `InsightsClient`         | Execution insights summary                       |
+| `sourceControl()`     | `SourceControlClient`    | Git-based source control pull                    |
+| `discover()`          | `DiscoverClient`         | API capability discovery                         |
+| `n8nPackage()`        | `N8nPackageClient`       | Package export/import (beta)                     |
 
 ## Documentation
 

package/chunk-2R6A6NJE.js

@@ -0,0 +1,38 @@
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/variable.ts
+var VariableResource = class extends BaseResource {
+  constructor(variables, variable, params) {
+    super(variable);
+    this.variables = variables;
+    this.params = params;
+  }
+  variables;
+  params;
+  get id() {
+    return this.data.id;
+  }
+  get key() {
+    return this.data.key;
+  }
+  get value() {
+    return this.data.value;
+  }
+  async refresh() {
+    return this.replaceSnapshot((await this.variables.getResource(this.id, this.params)).data);
+  }
+  async update(data) {
+    await this.variables.update(this.id, data);
+    return this.mergeSnapshot(data);
+  }
+  async delete() {
+    await this.variables.delete(this.id);
+  }
+};
+
+export {
+  VariableResource
+};
+//# sourceMappingURL=chunk-2R6A6NJE.js.map

package/chunk-3FDDCKAY.js

@@ -0,0 +1,95 @@
+import {
+  ProjectResource
+} from "./chunk-LTYQTCHM.js";
+import {
+  VariableClient
+} from "./chunk-HISH4ORK.js";
+import {
+  WorkflowClient
+} from "./chunk-54N6YD4R.js";
+import {
+  DataTableClient
+} from "./chunk-BQ2OTUXQ.js";
+import {
+  ExecutionClient
+} from "./chunk-C6W6ERQD.js";
+import {
+  FolderClient
+} from "./chunk-5DDMSYH2.js";
+import {
+  HttpError
+} from "./chunk-RMEH2UPX.js";
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/project.ts
+var ProjectClient = class extends BaseClient {
+  async list(params) {
+    return this.http.get("/projects", params);
+  }
+  async getResource(id) {
+    const project = await this.findProject(id);
+    if (!project) {
+      throw new HttpError(404, `Project not found: ${id}`, { id });
+    }
+    return this.createResource(project);
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((project) => this.createResource(project)),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    await this.http.post("/projects", data);
+  }
+  async update(id, data) {
+    await this.http.put(`/projects/${id}`, data);
+  }
+  async delete(id) {
+    await this.http.delete(`/projects/${id}`);
+  }
+  async listMembers(projectId, params) {
+    return this.http.get(`/projects/${projectId}/users`, params);
+  }
+  async addMembers(projectId, relations) {
+    await this.http.post(`/projects/${projectId}/users`, { relations });
+  }
+  async removeMember(projectId, userId) {
+    await this.http.delete(`/projects/${projectId}/users/${userId}`);
+  }
+  async changeMemberRole(projectId, userId, role) {
+    const data = { role };
+    await this.http.patch(`/projects/${projectId}/users/${userId}`, data);
+  }
+  createResource(project) {
+    return new ProjectResource(
+      this,
+      new WorkflowClient(this.http),
+      new FolderClient(this.http, project.id),
+      new VariableClient(this.http),
+      new DataTableClient(this.http),
+      new ExecutionClient(this.http),
+      project
+    );
+  }
+  async findProject(id) {
+    let cursor;
+    do {
+      const response = await this.list(cursor ? { cursor } : void 0);
+      const project = response.data.find((entry) => entry.id === id);
+      if (project) {
+        return project;
+      }
+      cursor = response.nextCursor;
+    } while (cursor);
+    return void 0;
+  }
+};
+
+export {
+  ProjectClient
+};
+//# sourceMappingURL=chunk-3FDDCKAY.js.map

package/chunk-3YWWR6UD.cjs

@@ -0,0 +1,98 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLC3TKRMXcjs = require('./chunk-LC3TKRMX.cjs');
+
+
+var _chunkFIKGC2ELcjs = require('./chunk-FIKGC2EL.cjs');
+
+// src/resources/workflow.ts
+var WorkflowResource = class extends _chunkFIKGC2ELcjs.BaseResource {
+  constructor(workflows, executionsClient, workflow) {
+    super(workflow);
+    this.workflows = workflows;
+    this.executionsClient = executionsClient;
+  }
+  
+  
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get active() {
+    return this.data.active;
+  }
+  get isArchived() {
+    return this.data.isArchived;
+  }
+  get versionId() {
+    return this.data.versionId;
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.workflows.update(this.id, data));
+  }
+  async delete() {
+    return this.workflows.delete(this.id);
+  }
+  async activate(data) {
+    return this.replaceSnapshot(await this.workflows.activate(this.id, data));
+  }
+  async deactivate() {
+    return this.replaceSnapshot(await this.workflows.deactivate(this.id));
+  }
+  async archive() {
+    return this.replaceSnapshot(await this.workflows.archive(this.id));
+  }
+  async unarchive() {
+    return this.replaceSnapshot(await this.workflows.unarchive(this.id));
+  }
+  async transfer(destinationProjectId) {
+    await this.workflows.transfer(this.id, destinationProjectId);
+  }
+  async getTags() {
+    return this.workflows.getTags(this.id);
+  }
+  async updateTags(tags) {
+    const updatedTags = await this.workflows.updateTags(this.id, tags);
+    this.mergeSnapshot({ tags: updatedTags });
+    return updatedTags;
+  }
+  async getVersion(versionId) {
+    return this.workflows.getVersion(this.id, versionId);
+  }
+  executions() {
+    return {
+      list: (params) => this.executionsClient.list({ ...params, workflowId: this.id }),
+      listResources: (params) => this.executionsClient.listResources({ ...params, workflowId: this.id }),
+      get: async (id, params) => {
+        if (!await this.hasExecutionInWorkflow(id)) {
+          throw new (0, _chunkLC3TKRMXcjs.HttpError)(404, `Execution not found in workflow: ${id}`, { id, workflowId: this.id });
+        }
+        return this.executionsClient.get(id, params);
+      },
+      getResource: async (id, params) => {
+        if (!await this.hasExecutionInWorkflow(id)) {
+          throw new (0, _chunkLC3TKRMXcjs.HttpError)(404, `Execution not found in workflow: ${id}`, { id, workflowId: this.id });
+        }
+        return this.executionsClient.getResource(id, params);
+      }
+    };
+  }
+  async hasExecutionInWorkflow(id) {
+    let cursor;
+    do {
+      const response = await this.executionsClient.list({ workflowId: this.id, cursor });
+      if (response.data.some((execution) => execution.id === id)) {
+        return true;
+      }
+      cursor = response.nextCursor;
+    } while (cursor);
+    return false;
+  }
+};
+
+
+
+exports.WorkflowResource = WorkflowResource;
+//# sourceMappingURL=chunk-3YWWR6UD.cjs.map

package/chunk-4M2HGY3F.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/clients/base.ts
+var BaseClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  
+};
+
+
+
+exports.BaseClient = BaseClient;
+//# sourceMappingURL=chunk-4M2HGY3F.cjs.map