npm - @kadoa/node-sdk - Versions diffs - 0.13.0 → 0.14.1 - Mend

@kadoa/node-sdk 0.13.0 → 0.14.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/browser/index.global.js +13 -13
package/dist/browser/index.global.js.map +1 -1
package/dist/index.d.mts +935 -835
package/dist/index.d.ts +935 -835
package/dist/index.js +1254 -1514
package/dist/index.js.map +1 -1
package/dist/index.mjs +1238 -1513
package/dist/index.mjs.map +1 -1
package/package.json +68 -65

package/dist/index.mjs CHANGED Viewed

@@ -1,10 +1,10 @@
 import globalAxios5, { isAxiosError, AxiosError } from 'axios';
-import { v4 } from 'uuid';
-import { URL, URLSearchParams } from 'url';
 import createDebug from 'debug';
 import { upperFirst, camelCase, merge } from 'es-toolkit';
-import { z } from 'zod';
+import { URL, URLSearchParams } from 'url';
 import assert from 'assert';
+import { z } from 'zod';
+import { v4 } from 'uuid';
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -13,7 +13,120 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-// src/internal/runtime/exceptions/base.exception.ts
+// src/domains/extraction/extraction.acl.ts
+var FetchDataOptions = class {
+};
+var SchemaFieldDataType = {
+  Text: "TEXT",
+  Number: "NUMBER",
+  Date: "DATE",
+  Url: "URL",
+  Email: "EMAIL",
+  Image: "IMAGE",
+  Video: "VIDEO",
+  Phone: "PHONE",
+  Boolean: "BOOLEAN",
+  Location: "LOCATION",
+  Array: "ARRAY",
+  Object: "OBJECT"
+};
+// src/runtime/pagination/paginator.ts
+var PagedIterator = class {
+  constructor(fetchPage) {
+    this.fetchPage = fetchPage;
+  }
+  /**
+   * Fetch all items across all pages
+   * @param options Base options (page will be overridden)
+   * @returns Array of all items
+   */
+  async fetchAll(options = {}) {
+    const allItems = [];
+    let currentPage = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const result = await this.fetchPage({ ...options, page: currentPage });
+      allItems.push(...result.data);
+      const pagination = result.pagination;
+      hasMore = pagination.page !== void 0 && pagination.totalPages !== void 0 && pagination.page < pagination.totalPages;
+      currentPage++;
+    }
+    return allItems;
+  }
+  /**
+   * Create an async iterator for pages
+   * @param options Base options (page will be overridden)
+   * @returns Async generator that yields pages
+   */
+  async *pages(options = {}) {
+    let currentPage = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const result = await this.fetchPage({ ...options, page: currentPage });
+      yield result;
+      const pagination = result.pagination;
+      hasMore = pagination.page !== void 0 && pagination.totalPages !== void 0 && pagination.page < pagination.totalPages;
+      currentPage++;
+    }
+  }
+  /**
+   * Create an async iterator for individual items
+   * @param options Base options (page will be overridden)
+   * @returns Async generator that yields items
+   */
+  async *items(options = {}) {
+    for await (const page of this.pages(options)) {
+      for (const item of page.data) {
+        yield item;
+      }
+    }
+  }
+};
+// src/domains/extraction/services/data-fetcher.service.ts
+var DataFetcherService = class {
+  constructor(workflowsApi) {
+    this.workflowsApi = workflowsApi;
+    this.defaultLimit = 100;
+  }
+  /**
+   * Fetch a page of workflow data
+   */
+  async fetchData(options) {
+    const response = await this.workflowsApi.v4WorkflowsWorkflowIdDataGet({
+      ...options,
+      page: options.page ?? 1,
+      limit: options.limit ?? this.defaultLimit
+    });
+    const result = response.data;
+    return result;
+  }
+  /**
+   * Fetch all pages of workflow data
+   */
+  async fetchAllData(options) {
+    const iterator = new PagedIterator(
+      (pageOptions) => this.fetchData({ ...options, ...pageOptions })
+    );
+    return iterator.fetchAll({ limit: options.limit ?? this.defaultLimit });
+  }
+  /**
+   * Create an async iterator for paginated data fetching
+   */
+  async *fetchDataPages(options) {
+    const iterator = new PagedIterator(
+      (pageOptions) => this.fetchData({ ...options, ...pageOptions })
+    );
+    for await (const page of iterator.pages({
+      limit: options.limit ?? this.defaultLimit
+    })) {
+      yield page;
+    }
+  }
+};
+// src/runtime/exceptions/base.exception.ts
 var KadoaErrorCode = {
   AUTH_ERROR: "AUTH_ERROR",
   VALIDATION_ERROR: "VALIDATION_ERROR",
@@ -196,6 +309,128 @@ var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
     return "UNKNOWN";
   }
 };
+var createLogger = (namespace) => createDebug(`kadoa:${namespace}`);
+var logger = {
+  client: createLogger("client"),
+  wss: createLogger("wss"),
+  extraction: createLogger("extraction"),
+  http: createLogger("http"),
+  workflow: createLogger("workflow"),
+  crawl: createLogger("crawl"),
+  notifications: createLogger("notifications"),
+  schemas: createLogger("schemas"),
+  validation: createLogger("validation")
+};
+var _SchemaBuilder = class _SchemaBuilder {
+  constructor() {
+    this.fields = [];
+  }
+  entity(entityName) {
+    this.entityName = entityName;
+    return this;
+  }
+  /**
+   * Add a structured field to the schema
+   * @param name - Field name (alphanumeric only)
+   * @param description - Field description
+   * @param dataType - Data type (STRING, NUMBER, BOOLEAN, etc.)
+   * @param options - Optional field configuration
+   */
+  field(name, description, dataType, options) {
+    this.validateFieldName(name);
+    const requiresExample = _SchemaBuilder.TYPES_REQUIRING_EXAMPLE.includes(dataType);
+    if (requiresExample && !options?.example) {
+      throw new KadoaSdkException(
+        `Field "${name}" with type ${dataType} requires an example`,
+        { code: "VALIDATION_ERROR", details: { name, dataType } }
+      );
+    }
+    this.fields.push({
+      name,
+      description,
+      dataType,
+      fieldType: "SCHEMA",
+      example: options?.example,
+      isKey: options?.isKey
+    });
+    return this;
+  }
+  /**
+   * Add a classification field to categorize content
+   * @param name - Field name (alphanumeric only)
+   * @param description - Field description
+   * @param categories - Array of category definitions
+   */
+  classify(name, description, categories) {
+    this.validateFieldName(name);
+    this.fields.push({
+      name,
+      description,
+      fieldType: "CLASSIFICATION",
+      categories
+    });
+    return this;
+  }
+  /**
+   * Add raw page content to extract
+   * @param name - Raw content format(s): "html", "markdown", or "url"
+   */
+  raw(name) {
+    const names = Array.isArray(name) ? name : [name];
+    for (const name2 of names) {
+      const fieldName = `raw${upperFirst(camelCase(name2))}`;
+      if (this.fields.some((field) => field.name === fieldName)) {
+        continue;
+      }
+      this.fields.push({
+        name: fieldName,
+        description: `Raw page content in ${name2.toUpperCase()} format`,
+        fieldType: "METADATA",
+        metadataKey: name2
+      });
+    }
+    return this;
+  }
+  build() {
+    if (!this.entityName) {
+      throw new KadoaSdkException("Entity name is required", {
+        code: "VALIDATION_ERROR",
+        details: { entityName: this.entityName }
+      });
+    }
+    return {
+      entityName: this.entityName,
+      fields: this.fields
+    };
+  }
+  validateFieldName(name) {
+    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
+      throw new KadoaSdkException(
+        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
+        {
+          code: "VALIDATION_ERROR",
+          details: { name, pattern: "^[A-Za-z0-9]+$" }
+        }
+      );
+    }
+    const lowerName = name.toLowerCase();
+    if (this.fields.some((f) => f.name.toLowerCase() === lowerName)) {
+      throw new KadoaSdkException(`Duplicate field name: "${name}"`, {
+        code: "VALIDATION_ERROR",
+        details: { name }
+      });
+    }
+  }
+};
+_SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
+_SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
+  "STRING",
+  "IMAGE",
+  "LINK",
+  "OBJECT",
+  "ARRAY"
+];
+var SchemaBuilder = _SchemaBuilder;
 var BASE_PATH = "https://api.kadoa.com".replace(/\/+$/, "");
 var BaseAPI = class {
   constructor(configuration, basePath = BASE_PATH, axios2 = globalAxios5) {
@@ -2608,7 +2843,7 @@ var WorkflowsApiAxiosParamCreator = function(configuration) {
     /**
      * Retrieves a list of workflows with pagination and search capabilities
      * @summary Get a list of workflows
-     * @param {string} [search] Search term to filter workflows by name or URL
+     * @param {string} [search] Search term to filter workflows by name, URL, or workflow ID
      * @param {number} [skip] Number of items to skip
      * @param {number} [limit] Maximum number of items to return
      * @param {V4WorkflowsGetStateEnum} [state] Filter workflows by state
@@ -3442,7 +3677,7 @@ var WorkflowsApiFp = function(configuration) {
     /**
      * Retrieves a list of workflows with pagination and search capabilities
      * @summary Get a list of workflows
-     * @param {string} [search] Search term to filter workflows by name or URL
+     * @param {string} [search] Search term to filter workflows by name, URL, or workflow ID
      * @param {number} [skip] Number of items to skip
      * @param {number} [limit] Maximum number of items to return
      * @param {V4WorkflowsGetStateEnum} [state] Filter workflows by state
@@ -4050,809 +4285,277 @@ var Configuration = class {
   }
 };
-// src/version.ts
-var SDK_VERSION = "0.13.0";
-var SDK_NAME = "kadoa-node-sdk";
-var SDK_LANGUAGE = "node";
-// src/internal/runtime/config/constants.ts
-var PUBLIC_API_URI = process.env.KADOA_PUBLIC_API_URI ?? "https://api.kadoa.com";
-var WSS_API_URI = process.env.KADOA_WSS_API_URI ?? "wss://realtime.kadoa.com";
-var REALTIME_API_URI = process.env.KADOA_REALTIME_API_URI ?? "https://realtime.kadoa.com";
-var createLogger = (namespace) => createDebug(`kadoa:${namespace}`);
-var logger = {
-  client: createLogger("client"),
-  wss: createLogger("wss"),
-  extraction: createLogger("extraction"),
-  http: createLogger("http"),
-  workflow: createLogger("workflow"),
-  crawl: createLogger("crawl"),
-  notifications: createLogger("notifications"),
-  schemas: createLogger("schemas"),
-  validation: createLogger("validation")
-};
-// src/internal/domains/realtime/realtime.ts
-var debug = logger.wss;
-if (typeof WebSocket === "undefined") {
-  global.WebSocket = __require("ws");
-}
-var Realtime = class {
-  constructor(config) {
-    this.lastHeartbeat = Date.now();
-    this.isConnecting = false;
-    this.eventListeners = /* @__PURE__ */ new Set();
-    this.connectionListeners = /* @__PURE__ */ new Set();
-    this.errorListeners = /* @__PURE__ */ new Set();
-    if (!config.teamApiKey.startsWith("tk-")) {
-      throw new KadoaSdkException(
-        "Realtime connection requires a team API key (starting with 'tk-'). Provided key does not appear to be a team API key.",
-        {
-          code: "AUTH_ERROR",
-          details: { providedKeyPrefix: config.teamApiKey.substring(0, 3) }
-        }
-      );
-    }
-    this.teamApiKey = config.teamApiKey;
-    this.heartbeatInterval = config.heartbeatInterval || 1e4;
-    this.reconnectDelay = config.reconnectDelay || 5e3;
-    this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
-  }
-  async connect() {
-    if (this.isConnecting) return;
-    this.isConnecting = true;
-    try {
-      const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": `${this.teamApiKey}`,
-          "x-sdk-version": SDK_VERSION
-        }
-      });
-      const { access_token, team_id } = await response.json();
-      this.socket = new WebSocket(
-        `${WSS_API_URI}?access_token=${access_token}`
-      );
-      this.socket.onopen = () => {
-        this.isConnecting = false;
-        this.lastHeartbeat = Date.now();
-        if (this.socket?.readyState === WebSocket.OPEN) {
-          this.socket.send(
-            JSON.stringify({
-              action: "subscribe",
-              channel: team_id
-            })
-          );
-          debug("Connected to WebSocket");
-          this.notifyConnectionListeners(true);
-        }
-        this.startHeartbeatCheck();
-      };
-      this.socket.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          if (data.type === "heartbeat") {
-            this.handleHeartbeat();
-          } else {
-            if (data?.id) {
-              fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ id: data.id })
-              });
-            }
-            this.notifyEventListeners(data);
-          }
-        } catch (err) {
-          debug("Failed to parse incoming message: %O", err);
-        }
-      };
-      this.socket.onclose = () => {
-        debug("WebSocket disconnected. Attempting to reconnect...");
-        this.isConnecting = false;
-        this.stopHeartbeatCheck();
-        this.notifyConnectionListeners(false, "Connection closed");
-        setTimeout(() => this.connect(), this.reconnectDelay);
-      };
-      this.socket.onerror = (error) => {
-        debug("WebSocket error: %O", error);
-        this.isConnecting = false;
-        this.notifyErrorListeners(error);
-      };
-    } catch (err) {
-      debug("Failed to connect: %O", err);
-      this.isConnecting = false;
-      setTimeout(() => this.connect(), this.reconnectDelay);
-    }
-  }
-  handleHeartbeat() {
-    debug("Heartbeat received");
-    this.lastHeartbeat = Date.now();
-  }
-  notifyEventListeners(event) {
-    this.eventListeners.forEach((listener) => {
-      try {
-        listener(event);
-      } catch (error) {
-        debug("Error in event listener: %O", error);
-      }
-    });
-  }
-  notifyConnectionListeners(connected, reason) {
-    this.connectionListeners.forEach((listener) => {
-      try {
-        listener(connected, reason);
-      } catch (error) {
-        debug("Error in connection listener: %O", error);
-      }
-    });
-  }
-  notifyErrorListeners(error) {
-    this.errorListeners.forEach((listener) => {
-      try {
-        listener(error);
-      } catch (error2) {
-        debug("Error in error listener: %O", error2);
-      }
-    });
-  }
-  startHeartbeatCheck() {
-    this.missedHeartbeatCheckTimer = setInterval(() => {
-      if (Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
-        debug("No heartbeat received in 30 seconds! Closing connection.");
-        this.socket?.close();
-      }
-    }, this.heartbeatInterval);
-  }
-  stopHeartbeatCheck() {
-    if (this.missedHeartbeatCheckTimer) {
-      clearInterval(this.missedHeartbeatCheckTimer);
-    }
-  }
-  /**
-   * Subscribe to realtime events
-   * @param listener Function to handle incoming events
-   * @returns Function to unsubscribe
-   */
-  onEvent(listener) {
-    this.eventListeners.add(listener);
-    return () => {
-      this.eventListeners.delete(listener);
-    };
+// src/domains/schemas/schemas.service.ts
+var debug = logger.schemas;
+var SchemasService = class {
+  constructor(client) {
+    this.schemasApi = new SchemasApi(client.configuration);
   }
   /**
-   * Subscribe to connection state changes
-   * @param listener Function to handle connection state changes
-   * @returns Function to unsubscribe
+   * Create a schema builder with fluent API and inline create support.
    */
-  onConnection(listener) {
-    this.connectionListeners.add(listener);
-    return () => {
-      this.connectionListeners.delete(listener);
-    };
+  builder(entityName) {
+    const service = this;
+    return new class extends SchemaBuilder {
+      constructor() {
+        super();
+        this.entity(entityName);
+      }
+      async create(name) {
+        const built = this.build();
+        return service.createSchema({
+          name: name || built.entityName,
+          entity: built.entityName,
+          fields: built.fields
+        });
+      }
+    }();
   }
   /**
-   * Subscribe to errors
-   * @param listener Function to handle errors
-   * @returns Function to unsubscribe
+   * Get a schema by ID
    */
-  onError(listener) {
-    this.errorListeners.add(listener);
-    return () => {
-      this.errorListeners.delete(listener);
-    };
-  }
-  close() {
-    if (this.socket) {
-      this.stopHeartbeatCheck();
-      this.socket.close();
-      this.socket = void 0;
+  async getSchema(schemaId) {
+    debug("Fetching schema with ID: %s", schemaId);
+    const response = await this.schemasApi.v4SchemasSchemaIdGet({
+      schemaId
+    });
+    const schemaData = response.data.data;
+    if (!schemaData) {
+      throw new KadoaSdkException(
+        `${ERROR_MESSAGES.SCHEMA_NOT_FOUND}: ${schemaId}`,
+        {
+          code: KadoaErrorCode.NOT_FOUND,
+          details: { schemaId }
+        }
+      );
     }
-    this.eventListeners.clear();
-    this.connectionListeners.clear();
-    this.errorListeners.clear();
-  }
-  isConnected() {
-    return this.socket?.readyState === WebSocket.OPEN;
-  }
-};
-// src/modules/extraction.module.ts
-var ExtractionModule = class {
-  constructor(extractionService, dataFetcherService, channelsService, settingsService, workflowsCoreService) {
-    this.extractionService = extractionService;
-    this.dataFetcherService = dataFetcherService;
-    this.channelsService = channelsService;
-    this.settingsService = settingsService;
-    this.workflowsCoreService = workflowsCoreService;
+    return schemaData;
   }
   /**
-   * Run extraction workflow using dynamic entity detection
-   *
-   * @param options Extraction configuration options including optional notification settings
-   * @returns ExtractionResult containing workflow ID, workflow details, and first page of extracted data
-   *
-   * @example Simple extraction with AI detection
-   * ```typescript
-   * const result = await client.extraction.run({
-   *   urls: ['https://example.com'],
-   *   name: 'My Extraction'
-   * });
-   * ```
-   *
-   * @example With notifications
-   * ```typescript
-   * const result = await client.extraction.run({
-   *   urls: ['https://example.com'],
-   *   name: 'My Extraction',
-   *   notifications: {
-   *     events: ['workflow_completed', 'workflow_failed'],
-   *     channels: {
-   *       email: true,
-   *       slack: { channelId: 'slack-channel-id' }
-   *     }
-   *   }
-   * });
-   * ```
-   *
-   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
+   * List all schemas
    */
-  async run(options) {
-    return await this.extractionService.executeExtraction({
-      ...options,
-      mode: "run"
-    });
+  async listSchemas() {
+    const response = await this.schemasApi.v4SchemasGet();
+    return response.data.data;
   }
   /**
-   * Submit extraction workflow for background processing
-   *
-   * @param options Extraction configuration options including optional notification settings
-   * @returns SubmitExtractionResult containing workflow ID
-   *
-   * @example
-   * ```typescript
-   * const result = await client.extraction.submit({
-   *   urls: ['https://example.com'],
-   *   name: 'My Extraction',
-   *   notifications: {
-   *     events: 'all',
-   *     channels: {
-   *       email: true
-   *     }
-   *   }
-   * });
-   * ```
-   *
-   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
+   * Create a new schema
    */
-  async submit(options) {
-    return await this.extractionService.executeExtraction({
-      ...options,
-      mode: "submit"
+  async createSchema(body) {
+    debug("Creating schema with name: %s", body.name);
+    const response = await this.schemasApi.v4SchemasPost({
+      createSchemaBody: body
     });
+    const schemaId = response.data.schemaId;
+    if (!schemaId) {
+      throw new KadoaSdkException(ERROR_MESSAGES.SCHEMA_CREATE_FAILED, {
+        code: KadoaErrorCode.INTERNAL_ERROR
+      });
+    }
+    return this.getSchema(schemaId);
   }
   /**
-   * Run a workflow with variables and optional limit
+   * Update an existing schema
    */
-  async runJob(workflowId, input) {
-    return this.workflowsCoreService.runWorkflow(workflowId, input);
+  async updateSchema(schemaId, body) {
+    debug("Updating schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdPut({
+      schemaId,
+      updateSchemaBody: body
+    });
+    return this.getSchema(schemaId);
   }
   /**
-   * Run a workflow and wait for it to complete
+   * Delete a schema
    */
-  async runJobAndWait(workflowId, input) {
-    const result = await this.workflowsCoreService.runWorkflow(
-      workflowId,
-      input
-    );
-    return this.workflowsCoreService.waitForJobCompletion(
-      workflowId,
-      result.jobId
-    );
+  async deleteSchema(schemaId) {
+    debug("Deleting schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdDelete({
+      schemaId
+    });
   }
-  /**
-   * Fetch paginated data from a workflow
-   *
-   * @param options Options for fetching data including workflowId and pagination parameters
-   * @returns Paginated workflow data with metadata
-   *
-   * @example
-   * ```typescript
-   * // Fetch first page
-   * const firstPage = await client.extraction.fetchData({
-   *   workflowId: 'workflow-id',
-   *   page: 1,
-   *   limit: 100
-   * });
-   *
-   * // Iterate through all pages
-   * for await (const page of client.extraction.fetchDataPages({ workflowId: 'workflow-id' })) {
-   *   console.log(`Processing ${page.data.length} records`);
-   * }
-   * ```
-   */
-  async fetchData(options) {
-    return this.dataFetcherService.fetchData(options);
+};
+// src/domains/extraction/services/entity-resolver.service.ts
+var ENTITY_API_ENDPOINT = "/v4/entity";
+var EntityResolverService = class {
+  constructor(client) {
+    this.client = client;
+    this.schemasService = new SchemasService(client);
   }
   /**
-   * Fetch all data from a workflow across all pages
-   *
-   * @param options Options for fetching data
-   * @returns All workflow data combined from all pages
+   * Resolves entity and fields from the provided entity configuration
    *
-   * @example
-   * ```typescript
-   * const allData = await client.extraction.fetchAllData({
-   *   workflowId: 'workflow-id'
-   * });
-   * ```
+   * @param entityConfig The entity configuration to resolve
+   * @param options Additional options for AI detection
+   * @returns Resolved entity with fields
    */
-  async fetchAllData(options) {
-    return this.dataFetcherService.fetchAllData(options);
-  }
-  /**
-   * Create an async iterator for paginated data fetching
-   *
-   * @param options Options for fetching data
-   * @returns Async iterator that yields pages of data
-   *
-   * @example
-   * ```typescript
-   * for await (const page of client.extraction.fetchDataPages({ workflowId: 'workflow-id' })) {
-   *   console.log(`Page ${page.pagination.page}: ${page.data.length} records`);
-   * }
-   * ```
-   */
-  fetchDataPages(options) {
-    return this.dataFetcherService.fetchDataPages(options);
-  }
-  /**
-   * Get notification channels for a workflow
-   *
-   * @param workflowId The workflow ID
-   * @returns Array of notification channels
-   *
-   * @example
-   * ```typescript
-   * const channels = await client.extraction.getNotificationChannels('workflow-id');
-   * ```
-   */
-  async getNotificationChannels(workflowId) {
-    return this.channelsService.listChannels({ workflowId });
+  async resolveEntity(entityConfig, options) {
+    if (entityConfig === "ai-detection") {
+      if (!options?.link) {
+        throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
+          code: "VALIDATION_ERROR",
+          details: { entityConfig, options }
+        });
+      }
+      const entityPrediction = await this.fetchEntityFields({
+        link: options.link,
+        location: options.location,
+        navigationMode: options.navigationMode
+      });
+      return {
+        entity: entityPrediction.entity,
+        fields: entityPrediction.fields
+      };
+    } else if (entityConfig) {
+      if ("schemaId" in entityConfig) {
+        const schema = await this.schemasService.getSchema(
+          entityConfig.schemaId
+        );
+        return {
+          entity: schema.entity ?? "",
+          fields: schema.schema
+        };
+      } else if ("name" in entityConfig && "fields" in entityConfig) {
+        return {
+          entity: entityConfig.name,
+          fields: entityConfig.fields
+        };
+      }
+    }
+    throw new KadoaSdkException(ERROR_MESSAGES.ENTITY_INVARIANT_VIOLATION, {
+      details: {
+        entity: entityConfig
+      }
+    });
   }
   /**
-   * Get notification settings for a workflow
-   *
-   * @param workflowId The workflow ID
-   * @returns Array of notification settings
+   * Fetches entity fields dynamically from the /v4/entity endpoint.
+   * This is a workaround implementation using native fetch since the endpoint
+   * is not yet included in the OpenAPI specification.
    *
-   * @example
-   * ```typescript
-   * const settings = await client.extraction.getNotificationSettings('workflow-id');
-   * ```
+   * @param options Request options including the link to analyze
+   * @returns EntityPrediction containing the detected entity type and fields
    */
-  async getNotificationSettings(workflowId) {
-    return this.settingsService.listSettings({ workflowId });
-  }
-};
-// src/modules/notifications.module.ts
-var NotificationsModule = class {
-  constructor(channelsService, settingsService, channelSetupService) {
-    this.channelsService = channelsService;
-    this.settingsService = settingsService;
-    this.channelSetupService = channelSetupService;
-  }
-  async setupForWorkflow(requestData) {
-    const existingSettings = await this.settingsService.listSettings({
-      workflowId: requestData.workflowId
+  async fetchEntityFields(options) {
+    this.validateEntityOptions(options);
+    const url = `${this.client.baseUrl}${ENTITY_API_ENDPOINT}`;
+    const requestBody = options;
+    const response = await this.client.axiosInstance.post(url, requestBody, {
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "x-api-key": this.client.apiKey
+      }
     });
-    if (existingSettings.length > 0) {
-      throw new KadoaSdkException("Settings already exist", {
-        code: KadoaErrorCode.BAD_REQUEST,
+    const data = response.data;
+    if (!data.success || !data.entityPrediction || data.entityPrediction.length === 0) {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_PREDICTIONS, {
+        code: "NOT_FOUND",
         details: {
-          workflowId: requestData.workflowId
+          success: data.success,
+          hasPredictions: !!data.entityPrediction,
+          predictionCount: data.entityPrediction?.length || 0,
+          link: options.link
         }
       });
     }
-    return this.channelSetupService.setup({
-      workflowId: requestData.workflowId,
-      events: requestData.events,
-      channels: requestData.channels
-    });
+    return data.entityPrediction[0];
   }
-  async setupForWorkspace(requestData) {
-    const existingSettings = await this.settingsService.listSettings({});
-    if (existingSettings.length > 0) {
-      throw new KadoaSdkException("Workspace settings already exist", {
-        code: KadoaErrorCode.BAD_REQUEST
+  /**
+   * Validates entity request options
+   */
+  validateEntityOptions(options) {
+    if (!options.link) {
+      throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
+        code: "VALIDATION_ERROR",
+        details: { options }
       });
     }
-    return this.channelSetupService.setup({
-      events: requestData.events,
-      channels: requestData.channels
-    });
+  }
+};
+var debug2 = logger.extraction;
+var SUCCESSFUL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS"]);
+var DEFAULT_OPTIONS = {
+  mode: "run",
+  pollingInterval: 5e3,
+  maxWaitTime: 3e5,
+  navigationMode: "single-page",
+  location: { type: "auto" },
+  name: "Untitled Workflow",
+  bypassPreview: true,
+  autoStart: true
+};
+var ExtractionService = class {
+  constructor(workflowsCoreService, dataFetcherService, entityResolverService, notificationSetupService, notificationChannelsService, notificationSettingsService) {
+    this.workflowsCoreService = workflowsCoreService;
+    this.dataFetcherService = dataFetcherService;
+    this.entityResolverService = entityResolverService;
+    this.notificationSetupService = notificationSetupService;
+    this.notificationChannelsService = notificationChannelsService;
+    this.notificationSettingsService = notificationSettingsService;
   }
   /**
-   * Get the channels service
+   * Run an extraction workflow and wait for completion.
    */
-  get channels() {
-    return this.channelsService;
+  async run(options) {
+    return await this.executeExtraction({ ...options, mode: "run" });
   }
   /**
-   * Get the settings service
+   * Submit an extraction workflow for asynchronous processing.
    */
-  get settings() {
-    return this.settingsService;
-  }
-};
-var _SchemaBuilder = class _SchemaBuilder {
-  constructor() {
-    this.fields = [];
-  }
-  entity(entityName) {
-    this.entityName = entityName;
-    return this;
+  async submit(options) {
+    return await this.executeExtraction({ ...options, mode: "submit" });
   }
   /**
-   * Add a structured field to the schema
-   * @param name - Field name (alphanumeric only)
-   * @param description - Field description
-   * @param dataType - Data type (STRING, NUMBER, BOOLEAN, etc.)
-   * @param options - Optional field configuration
+   * Trigger a workflow run without waiting for completion.
    */
-  field(name, description, dataType, options) {
-    this.validateFieldName(name);
-    const requiresExample = _SchemaBuilder.TYPES_REQUIRING_EXAMPLE.includes(dataType);
-    if (requiresExample && !options?.example) {
-      throw new KadoaSdkException(
-        `Field "${name}" with type ${dataType} requires an example`,
-        { code: "VALIDATION_ERROR", details: { name, dataType } }
-      );
-    }
-    this.fields.push({
-      name,
-      description,
-      dataType,
-      fieldType: "SCHEMA",
-      example: options?.example,
-      isKey: options?.isKey
-    });
-    return this;
+  async runJob(workflowId, input) {
+    return await this.workflowsCoreService.runWorkflow(workflowId, input);
   }
   /**
-   * Add a classification field to categorize content
-   * @param name - Field name (alphanumeric only)
-   * @param description - Field description
-   * @param categories - Array of category definitions
+   * Trigger a workflow run and wait for the job to complete.
    */
-  classify(name, description, categories) {
-    this.validateFieldName(name);
-    this.fields.push({
-      name,
-      description,
-      fieldType: "CLASSIFICATION",
-      categories
-    });
-    return this;
+  async runJobAndWait(workflowId, input) {
+    const result = await this.workflowsCoreService.runWorkflow(
+      workflowId,
+      input
+    );
+    return await this.workflowsCoreService.waitForJobCompletion(
+      workflowId,
+      result.jobId || ""
+    );
   }
   /**
-   * Add raw page content to extract
-   * @param name - Raw content format(s): "html", "markdown", or "url"
+   * Fetch a single page of extraction data.
    */
-  raw(name) {
-    const names = Array.isArray(name) ? name : [name];
-    for (const name2 of names) {
-      const fieldName = `raw${upperFirst(camelCase(name2))}`;
-      if (this.fields.some((field) => field.name === fieldName)) {
-        continue;
-      }
-      this.fields.push({
-        name: fieldName,
-        description: `Raw page content in ${name2.toUpperCase()} format`,
-        fieldType: "METADATA",
-        metadataKey: name2
-      });
-    }
-    return this;
-  }
-  build() {
-    if (!this.entityName) {
-      throw new KadoaSdkException("Entity name is required", {
-        code: "VALIDATION_ERROR",
-        details: { entityName: this.entityName }
-      });
-    }
-    return {
-      entityName: this.entityName,
-      fields: this.fields
-    };
-  }
-  validateFieldName(name) {
-    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
-      throw new KadoaSdkException(
-        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
-        {
-          code: "VALIDATION_ERROR",
-          details: { name, pattern: "^[A-Za-z0-9]+$" }
-        }
-      );
-    }
-    const lowerName = name.toLowerCase();
-    if (this.fields.some((f) => f.name.toLowerCase() === lowerName)) {
-      throw new KadoaSdkException(`Duplicate field name: "${name}"`, {
-        code: "VALIDATION_ERROR",
-        details: { name }
-      });
-    }
-  }
-};
-_SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
-_SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
-  "STRING",
-  "IMAGE",
-  "LINK",
-  "OBJECT",
-  "ARRAY"
-];
-var SchemaBuilder = _SchemaBuilder;
-// src/modules/schemas.module.ts
-var SchemaBuilderWithCreate = class extends SchemaBuilder {
-  constructor(entityName, service) {
-    super();
-    this.service = service;
-    this.entity(entityName);
+  async fetchData(options) {
+    return await this.dataFetcherService.fetchData(options);
   }
   /**
-   * Create the schema directly in Kadoa
-   * @param name - Optional schema name (defaults to entity name)
-   * @returns Promise resolving to the created schema
+   * Fetch all extraction data across all pages.
    */
-  async create(name) {
-    const built = this.build();
-    return this.service.createSchema({
-      name: name || built.entityName,
-      entity: built.entityName,
-      fields: built.fields
-    });
-  }
-};
-var SchemasModule = class {
-  constructor(service) {
-    this.service = service;
+  async fetchAllData(options) {
+    return await this.dataFetcherService.fetchAllData(options);
   }
   /**
-   * Create a new schema builder for fluent schema definition
-   * @param entityName - The name of the entity this schema represents
-   * @returns A new SchemaBuilder instance with the entity name already set
-   * @example Build then create
-   * ```typescript
-   * const schema = kadoa.schema.builder("Product")
-   *   .field("title", "Product name", "STRING", { example: "iPhone 15" })
-   *   .field("price", "Product price", "NUMBER")
-   *   .build();
-   *
-   * await kadoa.schema.create(schema);
-   * ```
-   *
-   * @example Fluent chain with create
-   * ```typescript
-   * const schema = await kadoa.schema.builder("Product")
-   *   .field("title", "Product name", "STRING", { example: "iPhone 15" })
-   *   .field("price", "Product price", "NUMBER")
-   *   .create("Product Schema");
-   * ```
-   */
-  builder(entityName) {
-    return new SchemaBuilderWithCreate(entityName, this.service);
-  }
-  /**
-   * Get a schema by ID
-   */
-  async get(schemaId) {
-    return this.service.getSchema(schemaId);
-  }
-  /**
-   * List all schemas
-   */
-  async list() {
-    return this.service.listSchemas();
-  }
-  /**
-   * Create a new schema from a body
-   */
-  async create(body) {
-    return this.service.createSchema(body);
-  }
-  /**
-   * Update an existing schema
-   */
-  async update(schemaId, body) {
-    return this.service.updateSchema(schemaId, body);
-  }
-  /**
-   * Delete a schema
-   */
-  async delete(schemaId) {
-    return this.service.deleteSchema(schemaId);
-  }
-};
-// src/modules/user.module.ts
-var UserModule = class {
-  constructor(userService) {
-    this.userService = userService;
-  }
-  /**
-   * Get the underlying UserService instance
-   * @returns UserService instance
-   */
-  get service() {
-    return this.userService;
-  }
-  /**
-   * Get current user details
-   * @returns KadoaUser details
-   */
-  async getCurrentUser() {
-    return this.userService.getCurrentUser();
-  }
-};
-// src/modules/validation.module.ts
-var ValidationModule = class {
-  constructor(coreService, rulesService) {
-    this.coreService = coreService;
-    this.rulesService = rulesService;
-  }
-  listRules(options) {
-    return this.rulesService.listRules(options);
-  }
-  getRuleByName(name) {
-    return this.rulesService.getRuleByName(name);
-  }
-  createRule(data) {
-    return this.rulesService.createRule(data);
-  }
-  generateRule(data) {
-    return this.rulesService.generateRule(data);
-  }
-  generateRules(data) {
-    return this.rulesService.generateRules(data);
-  }
-  bulkApproveRules(data) {
-    return this.rulesService.bulkApproveRules(data);
-  }
-  bulkDeleteRules(data) {
-    return this.rulesService.bulkDeleteRules(data);
-  }
-  deleteAllRules(data) {
-    return this.rulesService.deleteAllRules(data);
-  }
-  listWorkflowValidations(workflowId, jobId) {
-    return this.coreService.listWorkflowValidations({ workflowId, jobId });
-  }
-  scheduleValidation(workflowId, jobId) {
-    return this.coreService.scheduleValidation(workflowId, jobId);
-  }
-  waitUntilCompleted(validationId, options) {
-    return this.coreService.waitUntilCompleted(validationId, options);
-  }
-  getValidationDetails(validationId) {
-    return this.coreService.getValidationDetails(validationId);
-  }
-  getLatestValidation(workflowId, jobId) {
-    return this.coreService.getLatestValidation(workflowId, jobId);
-  }
-  getValidationAnomalies(validationId) {
-    return this.coreService.getValidationAnomalies(validationId);
-  }
-  getValidationAnomaliesByRule(validationId, ruleName) {
-    return this.coreService.getValidationAnomaliesByRule(
-      validationId,
-      ruleName
-    );
-  }
-  toggleValidationEnabled(workflowId) {
-    return this.coreService.toggleValidationEnabled(workflowId);
-  }
-};
-// src/modules/workflows.module.ts
-var WorkflowsModule = class {
-  constructor(core) {
-    this.core = core;
-  }
-  async get(workflowId) {
-    return this.core.get(workflowId);
-  }
-  async list(filters) {
-    return this.core.list(filters);
-  }
-  async getByName(name) {
-    return this.core.getByName(name);
-  }
-  async create(input) {
-    return this.core.create(input);
-  }
-  async cancel(workflowId) {
-    return this.core.cancel(workflowId);
-  }
-  async approve(workflowId) {
-    return this.core.resume(workflowId);
-  }
-  async resume(workflowId) {
-    return this.core.resume(workflowId);
-  }
-  async wait(workflowId, options) {
-    return this.core.wait(workflowId, options);
-  }
-  /**
-   * Get job status directly without polling workflow details
+   * Iterate through extraction data pages.
    */
-  async getJobStatus(workflowId, jobId) {
-    return this.core.getJobStatus(workflowId, jobId);
+  fetchDataPages(options) {
+    return this.dataFetcherService.fetchDataPages(options);
   }
   /**
-   * Wait for a job to complete using the job status endpoint
+   * List notification channels for a workflow.
    */
-  async waitForJobCompletion(workflowId, jobId, options) {
-    return this.core.waitForJobCompletion(workflowId, jobId, options);
-  }
-};
-// src/internal/domains/user/user.service.ts
-var UserService = class {
-  constructor(client) {
-    this.client = client;
+  async getNotificationChannels(workflowId) {
+    return await this.notificationChannelsService.listChannels({ workflowId });
   }
   /**
-   * Get current user details
-   * @returns User details
+   * List notification settings for a workflow.
    */
-  async getCurrentUser() {
-    const response = await this.client.axiosInstance.get("/v5/user", {
-      baseURL: this.client.baseUrl,
-      headers: {
-        "x-api-key": this.client.apiKey,
-        "Content-Type": "application/json"
-      }
-    });
-    const userData = response.data;
-    if (!userData || !userData.userId) {
-      throw new KadoaSdkException("Invalid user data received");
-    }
-    return {
-      userId: userData.userId,
-      email: userData.email,
-      featureFlags: userData.featureFlags || []
-    };
-  }
-};
-var debug2 = logger.extraction;
-var SUCCESSFUL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS"]);
-var DEFAULT_OPTIONS = {
-  mode: "run",
-  pollingInterval: 5e3,
-  maxWaitTime: 3e5,
-  navigationMode: "single-page",
-  location: { type: "auto" },
-  name: "Untitled Workflow",
-  bypassPreview: true,
-  autoStart: true
-};
-var ExtractionService = class {
-  constructor(workflowsCoreService, dataFetcherService, entityResolverService, notificationSetupService) {
-    this.workflowsCoreService = workflowsCoreService;
-    this.dataFetcherService = dataFetcherService;
-    this.entityResolverService = entityResolverService;
-    this.notificationSetupService = notificationSetupService;
+  async getNotificationSettings(workflowId) {
+    return await this.notificationSettingsService.listSettings({ workflowId });
   }
-  /**
-   * execute extraction workflow
-   */
   async executeExtraction(options) {
     this.validateOptions(options);
     const config = merge(
@@ -4975,96 +4678,270 @@ var ExtractionService = class {
     return runState ? SUCCESSFUL_RUN_STATES.has(runState.toUpperCase()) : false;
   }
 };
-var NotificationChannelType = {
-  EMAIL: "EMAIL",
-  SLACK: "SLACK",
-  WEBHOOK: "WEBHOOK",
-  WEBSOCKET: "WEBSOCKET"
-};
-var emailChannelConfigSchema = z.object({
-  recipients: z.array(z.email()).min(1, "Recipients are required for email channel"),
-  from: z.email().refine(
-    (email) => email.endsWith("@kadoa.com"),
-    "From email address must end with @kadoa.com"
-  ).optional()
-});
-var _NotificationChannelsService = class _NotificationChannelsService {
-  constructor(notificationsApi, userService) {
-    this.api = notificationsApi;
-    this.userService = userService;
+var debug3 = logger.extraction;
+var ExtractionBuilderService = class {
+  constructor(workflowsCoreService, entityResolverService, dataFetcherService, notificationSetupService) {
+    this.workflowsCoreService = workflowsCoreService;
+    this.entityResolverService = entityResolverService;
+    this.dataFetcherService = dataFetcherService;
+    this.notificationSetupService = notificationSetupService;
   }
-  async listChannels(filters) {
-    const response = await this.api.v5NotificationsChannelsGet(filters);
-    const data = response.data.data?.channels;
-    if (!data) {
-      throw KadoaHttpException.wrap(response, {
-        message: "Failed to list channels"
-      });
-    }
-    return data;
+  get options() {
+    assert(this._options, "Options are not set");
+    return this._options;
   }
-  /**
-   * List all channels (both workflow-specific and workspace-level)
-   * This is useful for finding workspace-level channels like WebSocket channels
-   * that might not be associated with a specific workflow
-   */
-  async listAllChannels(workflowId) {
-    if (!workflowId) {
-      return this.listChannels({});
-    }
-    const [workflowChannels, workspaceChannels] = await Promise.all([
-      this.listChannels({ workflowId }),
-      this.listChannels({})
-    ]);
-    const allChannels = [...workflowChannels];
-    workspaceChannels.forEach((channel) => {
-      if (!allChannels.find((c) => c.id === channel.id)) {
-        allChannels.push(channel);
-      }
-    });
-    return allChannels;
+  get notificationOptions() {
+    return this._notificationOptions;
   }
-  async deleteChannel(channelId) {
-    const response = await this.api.v5NotificationsChannelsChannelIdDelete({
-      channelId
-    });
-    if (response.status !== 200) {
-      throw KadoaHttpException.wrap(response, {
-        message: "Failed to delete channel"
-      });
-    }
+  get monitoringOptions() {
+    return this._monitoringOptions;
   }
-  async createChannel(type, config) {
-    const payload = await this.buildPayload(
-      merge(config || {}, {
-        name: _NotificationChannelsService.DEFAULT_CHANNEL_NAME,
-        channelType: type,
-        config: {}
-      })
-    );
-    const response = await this.api.v5NotificationsChannelsPost({
-      v5NotificationsChannelsPostRequest: payload
-    });
-    if (response.status === 201) {
-      const data = response.data.data?.channel;
-      if (!data) {
-        throw KadoaHttpException.wrap(response, {
-          message: "Failed to create default channels"
-        });
+  get workflowId() {
+    assert(this._workflowId, "Workflow ID is not set");
+    return this._workflowId;
+  }
+  get jobId() {
+    assert(this._jobId, "Job ID is not set");
+    return this._jobId;
+  }
+  extract({
+    urls,
+    name,
+    description,
+    navigationMode,
+    extraction
+  }) {
+    let entity = "ai-detection";
+    if (extraction) {
+      const result = extraction(new SchemaBuilder());
+      if ("schemaId" in result) {
+        entity = { schemaId: result.schemaId };
+      } else {
+        const builtSchema = result.build();
+        entity = { name: builtSchema.entityName, fields: builtSchema.fields };
       }
-      return data;
     }
-    throw KadoaHttpException.wrap(response, {
-      message: "Failed to create default channels"
-    });
+    this._options = {
+      urls,
+      name,
+      description,
+      navigationMode: navigationMode || "single-page",
+      entity,
+      bypassPreview: false
+    };
+    return this;
   }
-  async buildPayload(request) {
-    let config;
-    switch (request.channelType) {
-      case NotificationChannelType.EMAIL:
-        config = await this.buildEmailChannelConfig(
-          request.config
-        );
+  withNotifications(options) {
+    this._notificationOptions = options;
+    return this;
+  }
+  withMonitoring(options) {
+    this._monitoringOptions = options;
+    return this;
+  }
+  bypassPreview() {
+    assert(this._options, "Options are not set");
+    this._options.bypassPreview = true;
+    return this;
+  }
+  setInterval(options) {
+    assert(this._options, "Options are not set");
+    if ("interval" in options) {
+      this._options.interval = options.interval;
+    } else {
+      this._options.interval = "CUSTOM";
+      this._options.schedules = options.schedules;
+    }
+    return this;
+  }
+  setLocation(options) {
+    assert(this._options, "Options are not set");
+    this._options.location = options;
+    return this;
+  }
+  async create() {
+    assert(this._options, "Options are not set");
+    const { urls, name, description, navigationMode, entity } = this.options;
+    const resolvedEntity = typeof entity === "object" && "schemaId" in entity ? void 0 : await this.entityResolverService.resolveEntity(entity, {
+      link: urls[0],
+      location: this._options.location,
+      navigationMode
+    });
+    if (!resolvedEntity) {
+      throw new KadoaSdkException(ERROR_MESSAGES.ENTITY_FETCH_FAILED, {
+        code: "VALIDATION_ERROR",
+        details: { entity }
+      });
+    }
+    const workflow = await this.workflowsCoreService.create({
+      urls,
+      name,
+      description,
+      navigationMode,
+      monitoring: this._monitoringOptions,
+      schemaId: typeof entity === "object" && "schemaId" in entity ? entity.schemaId : void 0,
+      entity: resolvedEntity.entity,
+      fields: resolvedEntity.fields,
+      autoStart: false,
+      interval: this._options.interval,
+      schedules: this._options.schedules
+    });
+    if (this._notificationOptions) {
+      await this.notificationSetupService.setup({
+        ...this._notificationOptions,
+        workflowId: workflow.id
+      });
+    }
+    this._workflowId = workflow.id;
+    return this;
+  }
+  async run(options) {
+    assert(this._options, "Options are not set");
+    assert(this._workflowId, "Workflow ID is not set");
+    const startedJob = await this.workflowsCoreService.runWorkflow(
+      this._workflowId,
+      { variables: options?.variables, limit: options?.limit }
+    );
+    assert(startedJob.jobId, "Job ID is not set");
+    debug3("Job started: %O", startedJob);
+    this._jobId = startedJob.jobId;
+    const finishedJob = await this.workflowsCoreService.waitForJobCompletion(
+      this._workflowId,
+      startedJob.jobId
+    );
+    debug3("Job finished: %O", finishedJob);
+    return this;
+  }
+  async submit(options) {
+    assert(this._options, "Options are not set");
+    assert(this._workflowId, "Workflow ID is not set");
+    const submittedJob = await this.workflowsCoreService.runWorkflow(
+      this._workflowId,
+      { variables: options?.variables, limit: options?.limit }
+    );
+    assert(submittedJob.jobId, "Job ID is not set");
+    debug3("Job submitted: %O", submittedJob);
+    this._jobId = submittedJob.jobId;
+    return {
+      workflowId: this._workflowId,
+      jobId: this._jobId
+    };
+  }
+  async fetchData(options) {
+    assert(this._workflowId, "Workflow ID is not set");
+    assert(this._jobId, "Job ID is not set");
+    return this.dataFetcherService.fetchData({
+      workflowId: this._workflowId,
+      runId: this._jobId,
+      page: options.page ?? 1,
+      limit: options.limit ?? 100,
+      ...options
+    });
+  }
+  async fetchAllData(options) {
+    assert(this._jobId, "Job ID is not set");
+    assert(this._workflowId, "Workflow ID is not set");
+    return this.dataFetcherService.fetchAllData({
+      workflowId: this._workflowId,
+      runId: this._jobId,
+      ...options
+    });
+  }
+};
+// src/domains/notifications/notifications.acl.ts
+var NotificationChannelType = {
+  EMAIL: "EMAIL",
+  SLACK: "SLACK",
+  WEBHOOK: "WEBHOOK",
+  WEBSOCKET: "WEBSOCKET"
+};
+// src/domains/notifications/notification-channels.service.ts
+var emailChannelConfigSchema = z.object({
+  recipients: z.array(z.email()).min(1, "Recipients are required for email channel"),
+  from: z.email().refine(
+    (email) => email.endsWith("@kadoa.com"),
+    "From email address must end with @kadoa.com"
+  ).optional()
+});
+var _NotificationChannelsService = class _NotificationChannelsService {
+  constructor(notificationsApi, userService) {
+    this.api = notificationsApi;
+    this.userService = userService;
+  }
+  async listChannels(filters) {
+    const response = await this.api.v5NotificationsChannelsGet(filters);
+    const data = response.data.data?.channels;
+    if (!data) {
+      throw KadoaHttpException.wrap(response, {
+        message: "Failed to list channels"
+      });
+    }
+    return data;
+  }
+  /**
+   * List all channels (both workflow-specific and workspace-level)
+   * This is useful for finding workspace-level channels like WebSocket channels
+   * that might not be associated with a specific workflow
+   */
+  async listAllChannels(workflowId) {
+    if (!workflowId) {
+      return this.listChannels({});
+    }
+    const [workflowChannels, workspaceChannels] = await Promise.all([
+      this.listChannels({ workflowId }),
+      this.listChannels({})
+    ]);
+    const allChannels = [...workflowChannels];
+    workspaceChannels.forEach((channel) => {
+      if (!allChannels.find((c) => c.id === channel.id)) {
+        allChannels.push(channel);
+      }
+    });
+    return allChannels;
+  }
+  async deleteChannel(channelId) {
+    const response = await this.api.v5NotificationsChannelsChannelIdDelete({
+      channelId
+    });
+    if (response.status !== 200) {
+      throw KadoaHttpException.wrap(response, {
+        message: "Failed to delete channel"
+      });
+    }
+  }
+  async createChannel(type, config) {
+    const payload = await this.buildPayload(
+      merge(config || {}, {
+        name: _NotificationChannelsService.DEFAULT_CHANNEL_NAME,
+        channelType: type,
+        config: {}
+      })
+    );
+    const response = await this.api.v5NotificationsChannelsPost({
+      v5NotificationsChannelsPostRequest: payload
+    });
+    if (response.status === 201) {
+      const data = response.data.data?.channel;
+      if (!data) {
+        throw KadoaHttpException.wrap(response, {
+          message: "Failed to create default channels"
+        });
+      }
+      return data;
+    }
+    throw KadoaHttpException.wrap(response, {
+      message: "Failed to create default channels"
+    });
+  }
+  async buildPayload(request) {
+    let config;
+    switch (request.channelType) {
+      case NotificationChannelType.EMAIL:
+        config = await this.buildEmailChannelConfig(
+          request.config
+        );
         break;
       case NotificationChannelType.SLACK:
         config = await this.buildSlackChannelConfig(
@@ -5125,7 +5002,7 @@ var _NotificationChannelsService = class _NotificationChannelsService {
 _NotificationChannelsService.DEFAULT_CHANNEL_NAME = "default";
 var NotificationChannelsService = _NotificationChannelsService;
-// src/internal/domains/notifications/notification-settings.service.ts
+// src/domains/notifications/notification-settings.service.ts
 var NotificationSettingsService = class {
   constructor(notificationsApi) {
     this.api = notificationsApi;
@@ -5160,410 +5037,56 @@ var NotificationSettingsService = class {
       settingsId
     });
     if (response.status !== 200) {
-      throw KadoaHttpException.wrap(response, {
-        message: "Failed to delete notification settings"
-      });
-    }
-  }
-};
-// src/internal/runtime/pagination/paginator.ts
-var PagedIterator = class {
-  constructor(fetchPage) {
-    this.fetchPage = fetchPage;
-  }
-  /**
-   * Fetch all items across all pages
-   * @param options Base options (page will be overridden)
-   * @returns Array of all items
-   */
-  async fetchAll(options = {}) {
-    const allItems = [];
-    let currentPage = 1;
-    let hasMore = true;
-    while (hasMore) {
-      const result = await this.fetchPage({ ...options, page: currentPage });
-      allItems.push(...result.data);
-      const pagination = result.pagination;
-      hasMore = pagination.page !== void 0 && pagination.totalPages !== void 0 && pagination.page < pagination.totalPages;
-      currentPage++;
-    }
-    return allItems;
-  }
-  /**
-   * Create an async iterator for pages
-   * @param options Base options (page will be overridden)
-   * @returns Async generator that yields pages
-   */
-  async *pages(options = {}) {
-    let currentPage = 1;
-    let hasMore = true;
-    while (hasMore) {
-      const result = await this.fetchPage({ ...options, page: currentPage });
-      yield result;
-      const pagination = result.pagination;
-      hasMore = pagination.page !== void 0 && pagination.totalPages !== void 0 && pagination.page < pagination.totalPages;
-      currentPage++;
-    }
-  }
-  /**
-   * Create an async iterator for individual items
-   * @param options Base options (page will be overridden)
-   * @returns Async generator that yields items
-   */
-  async *items(options = {}) {
-    for await (const page of this.pages(options)) {
-      for (const item of page.data) {
-        yield item;
-      }
-    }
-  }
-};
-// src/internal/domains/extraction/services/data-fetcher.service.ts
-var DataFetcherService = class {
-  constructor(workflowsApi) {
-    this.workflowsApi = workflowsApi;
-    this.defaultLimit = 100;
-  }
-  /**
-   * Fetch a page of workflow data
-   */
-  async fetchData(options) {
-    const response = await this.workflowsApi.v4WorkflowsWorkflowIdDataGet({
-      ...options,
-      page: options.page ?? 1,
-      limit: options.limit ?? this.defaultLimit
-    });
-    const result = response.data;
-    return result;
-  }
-  /**
-   * Fetch all pages of workflow data
-   */
-  async fetchAllData(options) {
-    const iterator = new PagedIterator(
-      (pageOptions) => this.fetchData({ ...options, ...pageOptions })
-    );
-    return iterator.fetchAll({ limit: options.limit ?? this.defaultLimit });
-  }
-  /**
-   * Create an async iterator for paginated data fetching
-   */
-  async *fetchDataPages(options) {
-    const iterator = new PagedIterator(
-      (pageOptions) => this.fetchData({ ...options, ...pageOptions })
-    );
-    for await (const page of iterator.pages({
-      limit: options.limit ?? this.defaultLimit
-    })) {
-      yield page;
-    }
-  }
-};
-// src/internal/runtime/utils/polling.ts
-var DEFAULT_POLLING_OPTIONS = {
-  pollIntervalMs: 1e3,
-  timeoutMs: 5 * 60 * 1e3
-};
-var POLLING_ERROR_CODES = {
-  ABORTED: "ABORTED",
-  TIMEOUT: "TIMEOUT"
-};
-async function pollUntil(pollFn, isComplete, options = {}) {
-  const internalOptions = {
-    ...DEFAULT_POLLING_OPTIONS,
-    ...options
-  };
-  const pollInterval = Math.max(250, internalOptions.pollIntervalMs);
-  const timeoutMs = internalOptions.timeoutMs;
-  const start = Date.now();
-  let attempts = 0;
-  while (Date.now() - start < timeoutMs) {
-    if (internalOptions.abortSignal?.aborted) {
-      throw new KadoaSdkException("Polling operation was aborted", {
-        code: POLLING_ERROR_CODES.ABORTED
-      });
-    }
-    attempts++;
-    const current = await pollFn();
-    if (isComplete(current)) {
-      return {
-        result: current,
-        attempts,
-        duration: Date.now() - start
-      };
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
-  }
-  throw new KadoaSdkException(
-    `Polling operation timed out after ${timeoutMs}ms`,
-    {
-      code: POLLING_ERROR_CODES.TIMEOUT,
-      details: {
-        timeoutMs,
-        attempts,
-        duration: Date.now() - start
-      }
-    }
-  );
-}
-// src/internal/domains/workflows/types.ts
-var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
-  "FINISHED",
-  "FAILED",
-  "NOT_SUPPORTED",
-  "FAILED_INSUFFICIENT_FUNDS"
-]);
-// src/internal/domains/workflows/workflows-core.service.ts
-var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
-  "FINISHED",
-  "SUCCESS",
-  "FAILED",
-  "ERROR",
-  "STOPPED",
-  "CANCELLED"
-]);
-var debug3 = logger.workflow;
-var WorkflowsCoreService = class {
-  constructor(workflowsApi) {
-    this.workflowsApi = workflowsApi;
-  }
-  async create(input) {
-    const request = {
-      urls: input.urls,
-      name: input.name,
-      schemaId: input.schemaId,
-      description: input.description,
-      navigationMode: input.navigationMode,
-      entity: input.entity,
-      fields: input.fields,
-      bypassPreview: input.bypassPreview ?? true,
-      tags: input.tags,
-      interval: input.interval,
-      monitoring: input.monitoring,
-      location: input.location,
-      autoStart: input.autoStart,
-      schedules: input.schedules
-    };
-    const response = await this.workflowsApi.v4WorkflowsPost({
-      createWorkflowBody: request
-    });
-    const workflowId = response.data?.workflowId;
-    if (!workflowId) {
-      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
-        code: "INTERNAL_ERROR",
-        details: {
-          response: response.data
-        }
-      });
-    }
-    return { id: workflowId };
-  }
-  async get(id) {
-    const response = await this.workflowsApi.v4WorkflowsWorkflowIdGet({
-      workflowId: id
-    });
-    return response.data;
-  }
-  async list(filters) {
-    const response = await this.workflowsApi.v4WorkflowsGet(filters);
-    return response.data?.workflows ?? [];
-  }
-  async getByName(name) {
-    const response = await this.workflowsApi.v4WorkflowsGet({
-      search: name
-    });
-    return response.data?.workflows?.[0];
-  }
-  async cancel(id) {
-    await this.workflowsApi.v4WorkflowsWorkflowIdDelete({
-      workflowId: id
-    });
-  }
-  async resume(id) {
-    await this.workflowsApi.v4WorkflowsWorkflowIdResumePut({
-      workflowId: id
-    });
-  }
-  /**
-   * Wait for a workflow to reach the target state or a terminal state if no target state is provided
-   */
-  async wait(id, options) {
-    let last;
-    const result = await pollUntil(
-      async () => {
-        const current = await this.get(id);
-        if (last?.state !== current.state || last?.runState !== current.runState) {
-          debug3(
-            "workflow %s state: [workflowState: %s, jobState: %s]",
-            id,
-            current.state,
-            current.runState
-          );
-        }
-        last = current;
-        return current;
-      },
-      (current) => {
-        if (options?.targetState && current.state === options.targetState) {
-          return true;
-        }
-        if (current.runState && TERMINAL_RUN_STATES.has(current.runState.toUpperCase()) && current.state !== "QUEUED") {
-          return true;
-        }
-        return false;
-      },
-      options
-    );
-    return result.result;
-  }
-  /**
-   * Run a workflow with variables and optional limit
-   */
-  async runWorkflow(workflowId, input) {
-    const response = await this.workflowsApi.v4WorkflowsWorkflowIdRunPut({
-      workflowId,
-      v4WorkflowsWorkflowIdRunPutRequest: {
-        variables: input.variables,
-        limit: input.limit
-      }
-    });
-    const jobId = response.data?.jobId;
-    if (!jobId) {
-      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
-        code: "INTERNAL_ERROR",
-        details: {
-          response: response.data
-        }
-      });
-    }
-    return {
-      jobId,
-      message: response.data?.message,
-      status: response.data?.status
-    };
-  }
-  /**
-   * Get job status directly without polling workflow details
-   */
-  async getJobStatus(workflowId, jobId) {
-    const response = await this.workflowsApi.v4WorkflowsWorkflowIdJobsJobIdGet({
-      workflowId,
-      jobId
-    });
-    return response.data;
-  }
-  /**
-   * Wait for a job to reach the target state or a terminal state
-   */
-  async waitForJobCompletion(workflowId, jobId, options) {
-    let last;
-    const result = await pollUntil(
-      async () => {
-        const current = await this.getJobStatus(workflowId, jobId);
-        if (last?.state !== current.state) {
-          debug3("job %s state: %s", jobId, current.state);
-        }
-        last = current;
-        return current;
-      },
-      (current) => {
-        if (options?.targetStatus && current.state === options.targetStatus) {
-          return true;
-        }
-        if (current.state && TERMINAL_JOB_STATES.has(current.state)) {
-          return true;
-        }
-        return false;
-      },
-      options
-    );
-    return result.result;
-  }
-};
-// src/internal/domains/schemas/schemas.service.ts
-var debug4 = logger.schemas;
-var SchemasService = class {
-  constructor(client) {
-    this.schemasApi = new SchemasApi(client.configuration);
-  }
-  /**
-   * Get a schema by ID
-   */
-  async getSchema(schemaId) {
-    debug4("Fetching schema with ID: %s", schemaId);
-    const response = await this.schemasApi.v4SchemasSchemaIdGet({
-      schemaId
-    });
-    const schemaData = response.data.data;
-    if (!schemaData) {
-      throw new KadoaSdkException(
-        `${ERROR_MESSAGES.SCHEMA_NOT_FOUND}: ${schemaId}`,
-        {
-          code: KadoaErrorCode.NOT_FOUND,
-          details: { schemaId }
-        }
-      );
+      throw KadoaHttpException.wrap(response, {
+        message: "Failed to delete notification settings"
+      });
     }
-    return schemaData;
   }
-  /**
-   * List all schemas
-   */
-  async listSchemas() {
-    const response = await this.schemasApi.v4SchemasGet();
-    return response.data.data;
+};
+// src/domains/notifications/notification-setup.service.ts
+var debug4 = logger.notifications;
+var NotificationSetupService = class {
+  constructor(channelsService, settingsService) {
+    this.channelsService = channelsService;
+    this.settingsService = settingsService;
   }
   /**
-   * Create a new schema
+   * Setup notification settings for a specific workflow ensuring no duplicates exist.
    */
-  async createSchema(body) {
-    debug4("Creating schema with name: %s", body.name);
-    const response = await this.schemasApi.v4SchemasPost({
-      createSchemaBody: body
+  async setupForWorkflow(requestData) {
+    const existingSettings = await this.settingsService.listSettings({
+      workflowId: requestData.workflowId
     });
-    const schemaId = response.data.schemaId;
-    if (!schemaId) {
-      throw new KadoaSdkException(ERROR_MESSAGES.SCHEMA_CREATE_FAILED, {
-        code: KadoaErrorCode.INTERNAL_ERROR
+    if (existingSettings.length > 0) {
+      throw new KadoaSdkException("Settings already exist", {
+        code: KadoaErrorCode.BAD_REQUEST,
+        details: {
+          workflowId: requestData.workflowId
+        }
       });
     }
-    return this.getSchema(schemaId);
-  }
-  /**
-   * Update an existing schema
-   */
-  async updateSchema(schemaId, body) {
-    debug4("Updating schema with ID: %s", schemaId);
-    await this.schemasApi.v4SchemasSchemaIdPut({
-      schemaId,
-      updateSchemaBody: body
+    return this.setup({
+      workflowId: requestData.workflowId,
+      events: requestData.events,
+      channels: requestData.channels
     });
-    return this.getSchema(schemaId);
   }
   /**
-   * Delete a schema
+   * Setup notification settings at the workspace level ensuring no duplicates exist.
    */
-  async deleteSchema(schemaId) {
-    debug4("Deleting schema with ID: %s", schemaId);
-    await this.schemasApi.v4SchemasSchemaIdDelete({
-      schemaId
+  async setupForWorkspace(requestData) {
+    const existingSettings = await this.settingsService.listSettings({});
+    if (existingSettings.length > 0) {
+      throw new KadoaSdkException("Workspace settings already exist", {
+        code: KadoaErrorCode.BAD_REQUEST
+      });
+    }
+    return this.setup({
+      events: requestData.events,
+      channels: requestData.channels
     });
   }
-};
-// src/internal/domains/notifications/notification-setup.service.ts
-var debug5 = logger.notifications;
-var NotificationSetupService = class {
-  constructor(channelsService, settingsService) {
-    this.channelsService = channelsService;
-    this.settingsService = settingsService;
-  }
   /**
    * Complete workflow notification setup including channels and settings
    *
@@ -5571,10 +5094,10 @@ var NotificationSetupService = class {
    * @returns Array of created notification settings
    */
   async setup(requestData) {
-    requestData.workflowId ? debug5(
+    requestData.workflowId ? debug4(
       "Setting up notifications for workflow %s",
       requestData.workflowId
-    ) : debug5("Setting up notifications for workspace");
+    ) : debug4("Setting up notifications for workspace");
     const channels = await this.setupChannels({
       workflowId: requestData.workflowId,
       channels: requestData.channels || {}
@@ -5582,7 +5105,7 @@ var NotificationSetupService = class {
     const events = requestData.events || "all";
     const eventTypes = events === "all" ? await this.settingsService.listAllEvents() : events;
     const channelIds = channels.map((channel) => channel.id).filter(Boolean);
-    debug5(
+    debug4(
       "Creating notification settings for workflow %s: %O",
       requestData.workflowId,
       {
@@ -5601,7 +5124,7 @@ var NotificationSetupService = class {
         });
       })
     );
-    debug5(
+    debug4(
       requestData.workflowId ? "Successfully setup notifications for workflow %s" : "Successfully setup notifications for workspace",
       requestData.workflowId
     );
@@ -5683,7 +5206,7 @@ var NotificationSetupService = class {
           (channel2) => channel2.channelType === channelType && channel2.name === NotificationChannelsService.DEFAULT_CHANNEL_NAME
         );
         if (existingChannel) {
-          debug5("Using existing default channel: %O", {
+          debug4("Using existing default channel: %O", {
             workflowId,
             channelType,
             channelId: existingChannel.id
@@ -5691,7 +5214,7 @@ var NotificationSetupService = class {
           return existingChannel;
         }
         const channel = await this.channelsService.createChannel(channelType);
-        debug5("Created default channel %O", {
+        debug4("Created default channel %O", {
           workflowId,
           channelType,
           channel
@@ -5716,7 +5239,7 @@ var NotificationSetupService = class {
           (channel2) => channel2.channelType === channelType && (channel2.name || NotificationChannelsService.DEFAULT_CHANNEL_NAME) === channelName
         );
         if (existingChannel) {
-          debug5("Using existing channel: %O", {
+          debug4("Using existing channel: %O", {
             workflowId,
             channelType,
             channelName,
@@ -5728,7 +5251,7 @@ var NotificationSetupService = class {
           name: channelName,
           config
         });
-        debug5("Created channel with custom config %O", {
+        debug4("Created channel with custom config %O", {
           workflowId,
           channelType,
           channelName,
@@ -5741,7 +5264,280 @@ var NotificationSetupService = class {
   }
 };
-// src/internal/domains/validation/validation-core.service.ts
+// src/runtime/config/constants.ts
+var PUBLIC_API_URI = process.env.KADOA_PUBLIC_API_URI ?? "https://api.kadoa.com";
+var WSS_API_URI = process.env.KADOA_WSS_API_URI ?? "wss://realtime.kadoa.com";
+var REALTIME_API_URI = process.env.KADOA_REALTIME_API_URI ?? "https://realtime.kadoa.com";
+// src/version.ts
+var SDK_VERSION = "0.14.1";
+var SDK_NAME = "kadoa-node-sdk";
+var SDK_LANGUAGE = "node";
+// src/domains/realtime/realtime.ts
+var debug5 = logger.wss;
+if (typeof WebSocket === "undefined") {
+  global.WebSocket = __require("ws");
+}
+var Realtime = class {
+  constructor(config) {
+    this.lastHeartbeat = Date.now();
+    this.isConnecting = false;
+    this.eventListeners = /* @__PURE__ */ new Set();
+    this.connectionListeners = /* @__PURE__ */ new Set();
+    this.errorListeners = /* @__PURE__ */ new Set();
+    if (!config.teamApiKey.startsWith("tk-")) {
+      throw new KadoaSdkException(
+        "Realtime connection requires a team API key (starting with 'tk-'). Provided key does not appear to be a team API key.",
+        {
+          code: "AUTH_ERROR",
+          details: { providedKeyPrefix: config.teamApiKey.substring(0, 3) }
+        }
+      );
+    }
+    this.teamApiKey = config.teamApiKey;
+    this.heartbeatInterval = config.heartbeatInterval || 1e4;
+    this.reconnectDelay = config.reconnectDelay || 5e3;
+    this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
+  }
+  async connect() {
+    if (this.isConnecting) return;
+    this.isConnecting = true;
+    try {
+      const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": `${this.teamApiKey}`,
+          "x-sdk-version": SDK_VERSION
+        }
+      });
+      const { access_token, team_id } = await response.json();
+      this.socket = new WebSocket(
+        `${WSS_API_URI}?access_token=${access_token}`
+      );
+      this.socket.onopen = () => {
+        this.isConnecting = false;
+        this.lastHeartbeat = Date.now();
+        if (this.socket?.readyState === WebSocket.OPEN) {
+          this.socket.send(
+            JSON.stringify({
+              action: "subscribe",
+              channel: team_id
+            })
+          );
+          debug5("Connected to WebSocket");
+          this.notifyConnectionListeners(true);
+        }
+        this.startHeartbeatCheck();
+      };
+      this.socket.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === "heartbeat") {
+            this.handleHeartbeat();
+          } else {
+            if (data?.id) {
+              fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ id: data.id })
+              });
+            }
+            this.notifyEventListeners(data);
+          }
+        } catch (err) {
+          debug5("Failed to parse incoming message: %O", err);
+        }
+      };
+      this.socket.onclose = () => {
+        debug5("WebSocket disconnected. Attempting to reconnect...");
+        this.isConnecting = false;
+        this.stopHeartbeatCheck();
+        this.notifyConnectionListeners(false, "Connection closed");
+        setTimeout(() => this.connect(), this.reconnectDelay);
+      };
+      this.socket.onerror = (error) => {
+        debug5("WebSocket error: %O", error);
+        this.isConnecting = false;
+        this.notifyErrorListeners(error);
+      };
+    } catch (err) {
+      debug5("Failed to connect: %O", err);
+      this.isConnecting = false;
+      setTimeout(() => this.connect(), this.reconnectDelay);
+    }
+  }
+  handleHeartbeat() {
+    debug5("Heartbeat received");
+    this.lastHeartbeat = Date.now();
+  }
+  notifyEventListeners(event) {
+    this.eventListeners.forEach((listener) => {
+      try {
+        listener(event);
+      } catch (error) {
+        debug5("Error in event listener: %O", error);
+      }
+    });
+  }
+  notifyConnectionListeners(connected, reason) {
+    this.connectionListeners.forEach((listener) => {
+      try {
+        listener(connected, reason);
+      } catch (error) {
+        debug5("Error in connection listener: %O", error);
+      }
+    });
+  }
+  notifyErrorListeners(error) {
+    this.errorListeners.forEach((listener) => {
+      try {
+        listener(error);
+      } catch (error2) {
+        debug5("Error in error listener: %O", error2);
+      }
+    });
+  }
+  startHeartbeatCheck() {
+    this.missedHeartbeatCheckTimer = setInterval(() => {
+      if (Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
+        debug5("No heartbeat received in 30 seconds! Closing connection.");
+        this.socket?.close();
+      }
+    }, this.heartbeatInterval);
+  }
+  stopHeartbeatCheck() {
+    if (this.missedHeartbeatCheckTimer) {
+      clearInterval(this.missedHeartbeatCheckTimer);
+    }
+  }
+  /**
+   * Subscribe to realtime events
+   * @param listener Function to handle incoming events
+   * @returns Function to unsubscribe
+   */
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribe to connection state changes
+   * @param listener Function to handle connection state changes
+   * @returns Function to unsubscribe
+   */
+  onConnection(listener) {
+    this.connectionListeners.add(listener);
+    return () => {
+      this.connectionListeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribe to errors
+   * @param listener Function to handle errors
+   * @returns Function to unsubscribe
+   */
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => {
+      this.errorListeners.delete(listener);
+    };
+  }
+  close() {
+    if (this.socket) {
+      this.stopHeartbeatCheck();
+      this.socket.close();
+      this.socket = void 0;
+    }
+    this.eventListeners.clear();
+    this.connectionListeners.clear();
+    this.errorListeners.clear();
+  }
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+};
+// src/domains/user/user.service.ts
+var UserService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get current user details
+   * @returns User details
+   */
+  async getCurrentUser() {
+    const response = await this.client.axiosInstance.get("/v5/user", {
+      baseURL: this.client.baseUrl,
+      headers: {
+        "x-api-key": this.client.apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+    const userData = response.data;
+    if (!userData || !userData.userId) {
+      throw new KadoaSdkException("Invalid user data received");
+    }
+    return {
+      userId: userData.userId,
+      email: userData.email,
+      featureFlags: userData.featureFlags || []
+    };
+  }
+};
+// src/runtime/utils/polling.ts
+var DEFAULT_POLLING_OPTIONS = {
+  pollIntervalMs: 1e3,
+  timeoutMs: 5 * 60 * 1e3
+};
+var POLLING_ERROR_CODES = {
+  ABORTED: "ABORTED",
+  TIMEOUT: "TIMEOUT"
+};
+async function pollUntil(pollFn, isComplete, options = {}) {
+  const internalOptions = {
+    ...DEFAULT_POLLING_OPTIONS,
+    ...options
+  };
+  const pollInterval = Math.max(250, internalOptions.pollIntervalMs);
+  const timeoutMs = internalOptions.timeoutMs;
+  const start = Date.now();
+  let attempts = 0;
+  while (Date.now() - start < timeoutMs) {
+    if (internalOptions.abortSignal?.aborted) {
+      throw new KadoaSdkException("Polling operation was aborted", {
+        code: POLLING_ERROR_CODES.ABORTED
+      });
+    }
+    attempts++;
+    const current = await pollFn();
+    if (isComplete(current)) {
+      return {
+        result: current,
+        attempts,
+        duration: Date.now() - start
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  throw new KadoaSdkException(
+    `Polling operation timed out after ${timeoutMs}ms`,
+    {
+      code: POLLING_ERROR_CODES.TIMEOUT,
+      details: {
+        timeoutMs,
+        attempts,
+        duration: Date.now() - start
+      }
+    }
+  );
+}
+// src/domains/validation/validation-core.service.ts
 var ValidationCoreService = class {
   constructor(client) {
     this.validationApi = new DataValidationApi(
@@ -5815,7 +5611,7 @@ var ValidationCoreService = class {
         }
       );
     }
-    if (response.status !== 200 || response.data.error) {
+    if (response.status !== 200 || response.data?.error) {
       throw KadoaHttpException.wrap(response.data, {
         message: "Failed to get latest validation"
       });
@@ -5974,292 +5770,222 @@ var ValidationRulesService = class {
       bulkDeleteRules: data
     });
     if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to bulk delete validation rules"
-      });
-    }
-    return response.data.data;
-  }
-  async deleteAllRules(data) {
-    const response = await this.validationApi.v4DataValidationRulesActionsDeleteAllDelete({
-      deleteRuleWithReason: data
-    });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to delete all validation rules"
-      });
-    }
-    return response.data.data;
-  }
-};
-// src/internal/domains/extraction/services/entity-resolver.service.ts
-var ENTITY_API_ENDPOINT = "/v4/entity";
-var EntityResolverService = class {
-  constructor(client) {
-    this.client = client;
-    this.schemasService = new SchemasService(client);
-  }
-  /**
-   * Resolves entity and fields from the provided entity configuration
-   *
-   * @param entityConfig The entity configuration to resolve
-   * @param options Additional options for AI detection
-   * @returns Resolved entity with fields
-   */
-  async resolveEntity(entityConfig, options) {
-    if (entityConfig === "ai-detection") {
-      if (!options?.link) {
-        throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
-          code: "VALIDATION_ERROR",
-          details: { entityConfig, options }
-        });
-      }
-      const entityPrediction = await this.fetchEntityFields({
-        link: options.link,
-        location: options.location,
-        navigationMode: options.navigationMode
-      });
-      return {
-        entity: entityPrediction.entity,
-        fields: entityPrediction.fields
-      };
-    } else if (entityConfig) {
-      if ("schemaId" in entityConfig) {
-        const schema = await this.schemasService.getSchema(
-          entityConfig.schemaId
-        );
-        return {
-          entity: schema.entity ?? "",
-          fields: schema.schema
-        };
-      } else if ("name" in entityConfig && "fields" in entityConfig) {
-        return {
-          entity: entityConfig.name,
-          fields: entityConfig.fields
-        };
-      }
-    }
-    throw new KadoaSdkException(ERROR_MESSAGES.ENTITY_INVARIANT_VIOLATION, {
-      details: {
-        entity: entityConfig
-      }
-    });
-  }
-  /**
-   * Fetches entity fields dynamically from the /v4/entity endpoint.
-   * This is a workaround implementation using native fetch since the endpoint
-   * is not yet included in the OpenAPI specification.
-   *
-   * @param options Request options including the link to analyze
-   * @returns EntityPrediction containing the detected entity type and fields
-   */
-  async fetchEntityFields(options) {
-    this.validateEntityOptions(options);
-    const url = `${this.client.baseUrl}${ENTITY_API_ENDPOINT}`;
-    const requestBody = options;
-    const response = await this.client.axiosInstance.post(url, requestBody, {
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-api-key": this.client.apiKey
-      }
-    });
-    const data = response.data;
-    if (!data.success || !data.entityPrediction || data.entityPrediction.length === 0) {
-      throw new KadoaSdkException(ERROR_MESSAGES.NO_PREDICTIONS, {
-        code: "NOT_FOUND",
-        details: {
-          success: data.success,
-          hasPredictions: !!data.entityPrediction,
-          predictionCount: data.entityPrediction?.length || 0,
-          link: options.link
-        }
-      });
-    }
-    return data.entityPrediction[0];
-  }
-  /**
-   * Validates entity request options
-   */
-  validateEntityOptions(options) {
-    if (!options.link) {
-      throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
-        code: "VALIDATION_ERROR",
-        details: { options }
-      });
-    }
-  }
-};
-var debug7 = logger.extraction;
-var ExtractionBuilderService = class {
-  constructor(workflowsCoreService, entityResolverService, dataFetcherService, notificationSetupService) {
-    this.workflowsCoreService = workflowsCoreService;
-    this.entityResolverService = entityResolverService;
-    this.dataFetcherService = dataFetcherService;
-    this.notificationSetupService = notificationSetupService;
-  }
-  get options() {
-    assert(this._options, "Options are not set");
-    return this._options;
-  }
-  get notificationOptions() {
-    return this._notificationOptions;
-  }
-  get monitoringOptions() {
-    return this._monitoringOptions;
-  }
-  get workflowId() {
-    assert(this._workflowId, "Workflow ID is not set");
-    return this._workflowId;
-  }
-  get jobId() {
-    assert(this._jobId, "Job ID is not set");
-    return this._jobId;
-  }
-  extract({
-    urls,
-    name,
-    description,
-    navigationMode,
-    extraction
-  }) {
-    let entity = "ai-detection";
-    if (extraction) {
-      const result = extraction(new SchemaBuilder());
-      if ("schemaId" in result) {
-        entity = { schemaId: result.schemaId };
-      } else {
-        const builtSchema = result.build();
-        entity = { name: builtSchema.entityName, fields: builtSchema.fields };
-      }
-    }
-    this._options = {
-      urls,
-      name,
-      description,
-      navigationMode: navigationMode || "single-page",
-      entity,
-      bypassPreview: false
-    };
-    return this;
-  }
-  withNotifications(options) {
-    this._notificationOptions = options;
-    return this;
-  }
-  withMonitoring(options) {
-    this._monitoringOptions = options;
-    return this;
-  }
-  bypassPreview() {
-    assert(this._options, "Options are not set");
-    this._options.bypassPreview = true;
-    return this;
-  }
-  setInterval(options) {
-    assert(this._options, "Options are not set");
-    if ("interval" in options) {
-      this._options.interval = options.interval;
-    } else {
-      this._options.interval = "CUSTOM";
-      this._options.schedules = options.schedules;
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to bulk delete validation rules"
+      });
     }
-    return this;
-  }
-  setLocation(options) {
-    assert(this._options, "Options are not set");
-    this._options.location = options;
-    return this;
+    return response.data.data;
   }
-  async create() {
-    assert(this._options, "Options are not set");
-    const { urls, name, description, navigationMode, entity } = this.options;
-    const resolvedEntity = typeof entity === "object" && "schemaId" in entity ? void 0 : await this.entityResolverService.resolveEntity(entity, {
-      link: urls[0],
-      location: this._options.location,
-      navigationMode
+  async deleteAllRules(data) {
+    const response = await this.validationApi.v4DataValidationRulesActionsDeleteAllDelete({
+      deleteRuleWithReason: data
     });
-    if (!resolvedEntity) {
-      throw new KadoaSdkException(ERROR_MESSAGES.ENTITY_FETCH_FAILED, {
-        code: "VALIDATION_ERROR",
-        details: { entity }
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to delete all validation rules"
       });
     }
-    const workflow = await this.workflowsCoreService.create({
-      urls,
-      name,
-      description,
-      navigationMode,
-      monitoring: this._monitoringOptions,
-      schemaId: typeof entity === "object" && "schemaId" in entity ? entity.schemaId : void 0,
-      entity: resolvedEntity.entity,
-      fields: resolvedEntity.fields,
-      autoStart: false,
-      interval: this._options.interval,
-      schedules: this._options.schedules
+    return response.data.data;
+  }
+};
+// src/domains/workflows/workflows.acl.ts
+var JobStateEnum = {
+  Finished: "FINISHED",
+  Failed: "FAILED",
+  NotSupported: "NOT_SUPPORTED",
+  FailedInsufficientFunds: "FAILED_INSUFFICIENT_FUNDS"
+};
+// src/domains/workflows/workflows-core.service.ts
+var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
+  JobStateEnum.Finished,
+  JobStateEnum.Failed,
+  JobStateEnum.NotSupported,
+  JobStateEnum.FailedInsufficientFunds
+]);
+var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
+  "FINISHED",
+  "SUCCESS",
+  "FAILED",
+  "ERROR",
+  "STOPPED",
+  "CANCELLED"
+]);
+var debug6 = logger.workflow;
+var WorkflowsCoreService = class {
+  constructor(workflowsApi) {
+    this.workflowsApi = workflowsApi;
+  }
+  async create(input) {
+    const request = {
+      urls: input.urls,
+      name: input.name,
+      schemaId: input.schemaId,
+      description: input.description,
+      navigationMode: input.navigationMode,
+      entity: input.entity,
+      fields: input.fields,
+      bypassPreview: input.bypassPreview ?? true,
+      tags: input.tags,
+      interval: input.interval,
+      monitoring: input.monitoring,
+      location: input.location,
+      autoStart: input.autoStart,
+      schedules: input.schedules
+    };
+    const response = await this.workflowsApi.v4WorkflowsPost({
+      createWorkflowBody: request
     });
-    if (this._notificationOptions) {
-      await this.notificationSetupService.setup({
-        ...this._notificationOptions,
-        workflowId: workflow.id
+    const workflowId = response.data?.workflowId;
+    if (!workflowId) {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
+        code: "INTERNAL_ERROR",
+        details: {
+          response: response.data
+        }
       });
     }
-    this._workflowId = workflow.id;
-    return this;
+    return { id: workflowId };
   }
-  async run(options) {
-    assert(this._options, "Options are not set");
-    assert(this._workflowId, "Workflow ID is not set");
-    const startedJob = await this.workflowsCoreService.runWorkflow(
-      this._workflowId,
-      { variables: options?.variables, limit: options?.limit }
-    );
-    debug7("Job started: %O", startedJob);
-    this._jobId = startedJob.jobId;
-    const finishedJob = await this.workflowsCoreService.waitForJobCompletion(
-      this._workflowId,
-      startedJob.jobId
-    );
-    debug7("Job finished: %O", finishedJob);
-    return this;
+  async get(id) {
+    const response = await this.workflowsApi.v4WorkflowsWorkflowIdGet({
+      workflowId: id
+    });
+    return response.data;
   }
-  async submit(options) {
-    assert(this._options, "Options are not set");
-    assert(this._workflowId, "Workflow ID is not set");
-    const submittedJob = await this.workflowsCoreService.runWorkflow(
-      this._workflowId,
-      { variables: options?.variables, limit: options?.limit }
+  async list(filters) {
+    const response = await this.workflowsApi.v4WorkflowsGet(filters);
+    return response.data?.workflows ?? [];
+  }
+  async getByName(name) {
+    const response = await this.workflowsApi.v4WorkflowsGet({
+      search: name
+    });
+    return response.data?.workflows?.[0];
+  }
+  async cancel(id) {
+    await this.workflowsApi.v4WorkflowsWorkflowIdDelete({
+      workflowId: id
+    });
+  }
+  async resume(id) {
+    await this.workflowsApi.v4WorkflowsWorkflowIdResumePut({
+      workflowId: id
+    });
+  }
+  /**
+   * Wait for a workflow to reach the target state or a terminal state if no target state is provided
+   */
+  async wait(id, options) {
+    let last;
+    const result = await pollUntil(
+      async () => {
+        const current = await this.get(id);
+        if (last?.state !== current.state || last?.runState !== current.runState) {
+          debug6(
+            "workflow %s state: [workflowState: %s, jobState: %s]",
+            id,
+            current.state,
+            current.runState
+          );
+        }
+        last = current;
+        return current;
+      },
+      (current) => {
+        if (options?.targetState && current.state === options.targetState) {
+          return true;
+        }
+        if (current.runState && TERMINAL_RUN_STATES.has(current.runState.toUpperCase()) && current.state !== "QUEUED") {
+          return true;
+        }
+        return false;
+      },
+      options
     );
-    debug7("Job submitted: %O", submittedJob);
-    this._jobId = submittedJob.jobId;
+    return result.result;
+  }
+  /**
+   * Run a workflow with variables and optional limit
+   */
+  async runWorkflow(workflowId, input) {
+    const response = await this.workflowsApi.v4WorkflowsWorkflowIdRunPut({
+      workflowId,
+      v4WorkflowsWorkflowIdRunPutRequest: {
+        variables: input.variables,
+        limit: input.limit
+      }
+    });
+    const jobId = response.data?.jobId;
+    if (!jobId) {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
+        code: "INTERNAL_ERROR",
+        details: {
+          response: response.data
+        }
+      });
+    }
     return {
-      workflowId: this._workflowId,
-      jobId: this._jobId
+      jobId,
+      message: response.data?.message,
+      status: response.data?.status
     };
   }
-  async fetchData(options) {
-    assert(this._workflowId, "Workflow ID is not set");
-    assert(this._jobId, "Job ID is not set");
-    return this.dataFetcherService.fetchData({
-      workflowId: this._workflowId,
-      runId: this._jobId,
-      page: options.page ?? 1,
-      limit: options.limit ?? 100,
-      ...options
+  /**
+   * Get job status directly without polling workflow details
+   */
+  async getJobStatus(workflowId, jobId) {
+    const response = await this.workflowsApi.v4WorkflowsWorkflowIdJobsJobIdGet({
+      workflowId,
+      jobId
     });
+    return response.data;
   }
-  async fetchAllData(options) {
-    assert(this._jobId, "Job ID is not set");
-    assert(this._workflowId, "Workflow ID is not set");
-    return this.dataFetcherService.fetchAllData({
-      workflowId: this._workflowId,
-      runId: this._jobId,
-      ...options
-    });
+  /**
+   * Wait for a job to reach the target state or a terminal state
+   */
+  async waitForJobCompletion(workflowId, jobId, options) {
+    let last;
+    const result = await pollUntil(
+      async () => {
+        const current = await this.getJobStatus(workflowId, jobId);
+        if (last?.state !== current.state) {
+          debug6("job %s state: %s", jobId, current.state);
+        }
+        last = current;
+        return current;
+      },
+      (current) => {
+        if (options?.targetStatus && current.state === options.targetStatus) {
+          return true;
+        }
+        if (current.state && TERMINAL_JOB_STATES.has(current.state)) {
+          return true;
+        }
+        return false;
+      },
+      options
+    );
+    return result.result;
   }
 };
+// src/domains/validation/validation.facade.ts
+function createValidationDomain(core, rules) {
+  return {
+    rules,
+    schedule: (workflowId, jobId) => core.scheduleValidation(workflowId, jobId),
+    listWorkflowValidations: (filters) => core.listWorkflowValidations(filters),
+    getValidationDetails: (validationId) => core.getValidationDetails(validationId),
+    toggleEnabled: (workflowId) => core.toggleValidationEnabled(workflowId),
+    getLatest: (workflowId, jobId) => core.getLatestValidation(workflowId, jobId),
+    getAnomalies: (validationId) => core.getValidationAnomalies(validationId),
+    getAnomaliesByRule: (validationId, ruleName) => core.getValidationAnomaliesByRule(validationId, ruleName),
+    waitUntilCompleted: (validationId, options) => core.waitUntilCompleted(validationId, options)
+  };
+}
 // src/kadoa-client.ts
 var KadoaClient = class {
   constructor(config) {
@@ -6336,7 +6062,9 @@ var KadoaClient = class {
       workflowsCoreService,
       dataFetcherService,
       entityResolverService,
-      channelSetupService
+      channelSetupService,
+      channelsService,
+      settingsService
     );
     this._extractionBuilderService = new ExtractionBuilderService(
       workflowsCoreService,
@@ -6344,22 +6072,19 @@ var KadoaClient = class {
       dataFetcherService,
       channelSetupService
     );
-    this.user = new UserModule(userService);
-    this.extraction = new ExtractionModule(
-      extractionService,
-      dataFetcherService,
-      channelsService,
-      settingsService,
-      workflowsCoreService
-    );
-    this.workflow = new WorkflowsModule(workflowsCoreService);
-    this.schema = new SchemasModule(schemasService);
-    this.notification = new NotificationsModule(
-      channelsService,
-      settingsService,
-      channelSetupService
-    );
-    this.validation = new ValidationModule(coreService, rulesService);
+    this.user = userService;
+    this.extraction = extractionService;
+    this.workflow = workflowsCoreService;
+    this.schema = schemasService;
+    this.notification = {
+      channels: channelsService,
+      settings: settingsService,
+      setup: channelSetupService,
+      configure: (options) => channelSetupService.setup(options),
+      setupForWorkflow: (request) => channelSetupService.setupForWorkflow(request),
+      setupForWorkspace: (request) => channelSetupService.setupForWorkspace(request)
+    };
+    this.validation = createValidationDomain(coreService, rulesService);
     if (config.enableRealtime && config.realtimeConfig?.autoConnect !== false) {
       this.connectRealtime();
     }
@@ -6498,6 +6223,6 @@ var KadoaClient = class {
   }
 };
-export { ERROR_MESSAGES, KadoaClient, KadoaHttpException, KadoaSdkException, SchemaBuilder, SchemasModule, ValidationModule, pollUntil };
+export { DataFetcherService, ERROR_MESSAGES, EntityResolverService, ExtractionBuilderService, ExtractionService, FetchDataOptions, KadoaClient, KadoaHttpException, KadoaSdkException, NotificationChannelType, NotificationChannelsService, V5NotificationsSettingsGetEventTypeEnum as NotificationSettingsEventTypeEnum, NotificationSettingsService, NotificationSetupService, Realtime, SchemaBuilder, SchemaFieldDataType, SchemasService, UserService, ValidationCoreService, ValidationRulesService, WorkflowsCoreService, pollUntil };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map