@kadoa/node-sdk 0.12.1 → 0.14.1

package/dist/index.js

@@ -1,12 +1,12 @@
 'use strict';
 
 var globalAxios5 = require('axios');
-var uuid = require('uuid');
-var url = require('url');
 var createDebug = require('debug');
 var esToolkit = require('es-toolkit');
-var zod = require('zod');
+var url = require('url');
 var assert = require('assert');
+var zod = require('zod');
+var uuid = require('uuid');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -21,12 +21,127 @@ 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",
   BAD_REQUEST: "BAD_REQUEST",
-  NOT_FOUND: "NOT_FOUND"};
+  NOT_FOUND: "NOT_FOUND",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
 var _KadoaSdkException = class _KadoaSdkException extends Error {
   constructor(message, options) {
     super(message);
@@ -108,7 +223,10 @@ _KadoaSdkException.ERROR_MESSAGES = {
   // Schema specific errors
   SCHEMA_NOT_FOUND: "Schema not found",
   SCHEMA_FETCH_ERROR: "Failed to fetch schema",
-  SCHEMAS_FETCH_ERROR: "Failed to fetch schemas"
+  SCHEMAS_FETCH_ERROR: "Failed to fetch schemas",
+  SCHEMA_CREATE_FAILED: "Failed to create schema",
+  SCHEMA_UPDATE_FAILED: "Failed to update schema",
+  SCHEMA_DELETE_FAILED: "Failed to delete schema"
 };
 var KadoaSdkException = _KadoaSdkException;
 var ERROR_MESSAGES = KadoaSdkException.ERROR_MESSAGES;
@@ -199,6 +317,128 @@ var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
     return "UNKNOWN";
   }
 };
+var createLogger = (namespace) => createDebug__default.default(`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${esToolkit.upperFirst(esToolkit.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__default.default) {
@@ -2611,7 +2851,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
@@ -3445,7 +3685,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
@@ -4053,624 +4293,277 @@ var Configuration = class {
   }
 };
 
-// src/version.ts
-var SDK_VERSION = "0.12.1";
-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__default.default(`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-")) {
+// src/domains/schemas/schemas.service.ts
+var debug = logger.schemas;
+var SchemasService = class {
+  constructor(client) {
+    this.schemasApi = new SchemasApi(client.configuration);
+  }
+  /**
+   * Create a schema builder with fluent API and inline create support.
+   */
+  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
+        });
+      }
+    }();
+  }
+  /**
+   * Get a schema by ID
+   */
+  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(
-        "Realtime connection requires a team API key (starting with 'tk-'). Provided key does not appear to be a team API key.",
+        `${ERROR_MESSAGES.SCHEMA_NOT_FOUND}: ${schemaId}`,
         {
-          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
+          code: KadoaErrorCode.NOT_FOUND,
+          details: { schemaId }
         }
-      });
-      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);
     }
+    return schemaData;
   }
   /**
-   * Subscribe to realtime events
-   * @param listener Function to handle incoming events
-   * @returns Function to unsubscribe
+   * List all schemas
    */
-  onEvent(listener) {
-    this.eventListeners.add(listener);
-    return () => {
-      this.eventListeners.delete(listener);
-    };
+  async listSchemas() {
+    const response = await this.schemasApi.v4SchemasGet();
+    return response.data.data;
   }
   /**
-   * Subscribe to connection state changes
-   * @param listener Function to handle connection state changes
-   * @returns Function to unsubscribe
+   * Create a new schema
    */
-  onConnection(listener) {
-    this.connectionListeners.add(listener);
-    return () => {
-      this.connectionListeners.delete(listener);
-    };
+  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);
   }
   /**
-   * Subscribe to errors
-   * @param listener Function to handle errors
-   * @returns Function to unsubscribe
+   * Update an existing schema
    */
-  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();
+  async updateSchema(schemaId, body) {
+    debug("Updating schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdPut({
+      schemaId,
+      updateSchemaBody: body
+    });
+    return this.getSchema(schemaId);
   }
-  isConnected() {
-    return this.socket?.readyState === WebSocket.OPEN;
+  /**
+   * Delete a schema
+   */
+  async deleteSchema(schemaId) {
+    debug("Deleting schema with ID: %s", schemaId);
+    await this.schemasApi.v4SchemasSchemaIdDelete({
+      schemaId
+    });
   }
 };
 
-// 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;
+// 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);
   }
   /**
-   * 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' }
-   *     }
-   *   }
-   * });
-   * ```
+   * Resolves entity and fields from the provided entity configuration
    *
-   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
+   * @param entityConfig The entity configuration to resolve
+   * @param options Additional options for AI detection
+   * @returns Resolved entity with fields
    */
-  async run(options) {
-    return await this.extractionService.executeExtraction({
-      ...options,
-      mode: "run"
+  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
+      }
     });
   }
   /**
-   * 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
-   *     }
-   *   }
-   * });
-   * ```
+   * 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.
    *
-   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
+   * @param options Request options including the link to analyze
+   * @returns EntityPrediction containing the detected entity type and fields
    */
-  async submit(options) {
-    return await this.extractionService.executeExtraction({
-      ...options,
-      mode: "submit"
+  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];
   }
   /**
-   * Run a workflow with variables and optional limit
+   * Validates entity request options
    */
-  async runJob(workflowId, input) {
-    return this.workflowsCoreService.runWorkflow(workflowId, input);
+  validateEntityOptions(options) {
+    if (!options.link) {
+      throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
+        code: "VALIDATION_ERROR",
+        details: { options }
+      });
+    }
+  }
+};
+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;
+  }
+  /**
+   * Run an extraction workflow and wait for completion.
+   */
+  async run(options) {
+    return await this.executeExtraction({ ...options, mode: "run" });
+  }
+  /**
+   * Submit an extraction workflow for asynchronous processing.
+   */
+  async submit(options) {
+    return await this.executeExtraction({ ...options, mode: "submit" });
+  }
+  /**
+   * Trigger a workflow run without waiting for completion.
+   */
+  async runJob(workflowId, input) {
+    return await this.workflowsCoreService.runWorkflow(workflowId, input);
   }
   /**
-   * Run a workflow and wait for it to complete
+   * Trigger a workflow run and wait for the job to complete.
    */
   async runJobAndWait(workflowId, input) {
     const result = await this.workflowsCoreService.runWorkflow(
       workflowId,
       input
     );
-    return this.workflowsCoreService.waitForJobCompletion(
+    return await this.workflowsCoreService.waitForJobCompletion(
       workflowId,
-      result.jobId
+      result.jobId || ""
     );
   }
   /**
-   * 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`);
-   * }
-   * ```
+   * Fetch a single page of extraction data.
    */
   async fetchData(options) {
-    return this.dataFetcherService.fetchData(options);
+    return await this.dataFetcherService.fetchData(options);
   }
   /**
-   * Fetch all data from a workflow across all pages
-   *
-   * @param options Options for fetching data
-   * @returns All workflow data combined from all pages
-   *
-   * @example
-   * ```typescript
-   * const allData = await client.extraction.fetchAllData({
-   *   workflowId: 'workflow-id'
-   * });
-   * ```
+   * Fetch all extraction data across all pages.
    */
   async fetchAllData(options) {
-    return this.dataFetcherService.fetchAllData(options);
+    return await 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`);
-   * }
-   * ```
+   * Iterate through extraction data pages.
    */
   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');
-   * ```
+   * List notification channels for a workflow.
    */
   async getNotificationChannels(workflowId) {
-    return this.channelsService.listChannels({ workflowId });
+    return await this.notificationChannelsService.listChannels({ workflowId });
   }
   /**
-   * Get notification settings for a workflow
-   *
-   * @param workflowId The workflow ID
-   * @returns Array of notification settings
-   *
-   * @example
-   * ```typescript
-   * const settings = await client.extraction.getNotificationSettings('workflow-id');
-   * ```
+   * List notification settings for a workflow.
    */
   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
-    });
-    if (existingSettings.length > 0) {
-      throw new KadoaSdkException("Settings already exist", {
-        code: KadoaErrorCode.BAD_REQUEST,
-        details: {
-          workflowId: requestData.workflowId
-        }
-      });
-    }
-    return this.channelSetupService.setup({
-      workflowId: requestData.workflowId,
-      events: requestData.events,
-      channels: requestData.channels
-    });
-  }
-  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.channelSetupService.setup({
-      events: requestData.events,
-      channels: requestData.channels
-    });
-  }
-  /**
-   * Get the channels service
-   */
-  get channels() {
-    return this.channelsService;
-  }
-  /**
-   * Get the settings service
-   */
-  get settings() {
-    return this.settingsService;
-  }
-};
-
-// src/modules/schemas.module.ts
-var SchemasModule = class {
-  constructor(service) {
-    this.service = service;
-  }
-};
-
-// 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
-   */
-  async getJobStatus(workflowId, jobId) {
-    return this.core.getJobStatus(workflowId, jobId);
-  }
-  /**
-   * Wait for a job to complete using the job status endpoint
-   */
-  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;
-  }
-  /**
-   * 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 || []
-    };
-  }
-};
-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;
+    return await this.notificationSettingsService.listSettings({ workflowId });
   }
-  /**
-   * execute extraction workflow
-   */
   async executeExtraction(options) {
     this.validateOptions(options);
     const config = esToolkit.merge(
@@ -4793,54 +4686,228 @@ var ExtractionService = class {
     return runState ? SUCCESSFUL_RUN_STATES.has(runState.toUpperCase()) : false;
   }
 };
-var NotificationChannelType = {
-  EMAIL: "EMAIL",
-  SLACK: "SLACK",
-  WEBHOOK: "WEBHOOK",
-  WEBSOCKET: "WEBSOCKET"
-};
-var emailChannelConfigSchema = zod.z.object({
-  recipients: zod.z.array(zod.z.email()).min(1, "Recipients are required for email channel"),
-  from: zod.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__default.default(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;
+  }
+  get monitoringOptions() {
+    return this._monitoringOptions;
+  }
+  get workflowId() {
+    assert__default.default(this._workflowId, "Workflow ID is not set");
+    return this._workflowId;
+  }
+  get jobId() {
+    assert__default.default(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__default.default(this._options, "Options are not set");
+    this._options.bypassPreview = true;
+    return this;
+  }
+  setInterval(options) {
+    assert__default.default(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__default.default(this._options, "Options are not set");
+    this._options.location = options;
+    return this;
+  }
+  async create() {
+    assert__default.default(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__default.default(this._options, "Options are not set");
+    assert__default.default(this._workflowId, "Workflow ID is not set");
+    const startedJob = await this.workflowsCoreService.runWorkflow(
+      this._workflowId,
+      { variables: options?.variables, limit: options?.limit }
+    );
+    assert__default.default(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__default.default(this._options, "Options are not set");
+    assert__default.default(this._workflowId, "Workflow ID is not set");
+    const submittedJob = await this.workflowsCoreService.runWorkflow(
+      this._workflowId,
+      { variables: options?.variables, limit: options?.limit }
+    );
+    assert__default.default(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__default.default(this._workflowId, "Workflow ID is not set");
+    assert__default.default(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__default.default(this._jobId, "Job ID is not set");
+    assert__default.default(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 = zod.z.object({
+  recipients: zod.z.array(zod.z.email()).min(1, "Recipients are required for email channel"),
+  from: zod.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({
@@ -4943,7 +5010,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;
@@ -4985,360 +5052,48 @@ var NotificationSettingsService = class {
   }
 };
 
-// src/internal/runtime/pagination/paginator.ts
-var PagedIterator = class {
-  constructor(fetchPage) {
-    this.fetchPage = fetchPage;
+// src/domains/notifications/notification-setup.service.ts
+var debug4 = logger.notifications;
+var NotificationSetupService = class {
+  constructor(channelsService, settingsService) {
+    this.channelsService = channelsService;
+    this.settingsService = settingsService;
   }
   /**
-   * Fetch all items across all pages
-   * @param options Base options (page will be overridden)
-   * @returns Array of all items
+   * Setup notification settings for a specific workflow ensuring no duplicates exist.
    */
-  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++;
+  async setupForWorkflow(requestData) {
+    const existingSettings = await this.settingsService.listSettings({
+      workflowId: requestData.workflowId
+    });
+    if (existingSettings.length > 0) {
+      throw new KadoaSdkException("Settings already exist", {
+        code: KadoaErrorCode.BAD_REQUEST,
+        details: {
+          workflowId: requestData.workflowId
+        }
+      });
     }
-    return allItems;
+    return this.setup({
+      workflowId: requestData.workflowId,
+      events: requestData.events,
+      channels: requestData.channels
+    });
   }
   /**
-   * Create an async iterator for pages
-   * @param options Base options (page will be overridden)
-   * @returns Async generator that yields pages
+   * Setup notification settings at the workspace level ensuring no duplicates exist.
    */
-  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++;
+  async setupForWorkspace(requestData) {
+    const existingSettings = await this.settingsService.listSettings({});
+    if (existingSettings.length > 0) {
+      throw new KadoaSdkException("Workspace settings already exist", {
+        code: KadoaErrorCode.BAD_REQUEST
+      });
     }
-  }
-  /**
-   * 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
-   * //todo: use proper schema type for response from generated client (when avaialble)
-   */
-  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 }
-        }
-      );
-    }
-    return schemaData;
-  }
-};
-
-// src/internal/domains/notifications/notification-setup.service.ts
-var debug5 = logger.notifications;
-var NotificationSetupService = class {
-  constructor(channelsService, settingsService) {
-    this.channelsService = channelsService;
-    this.settingsService = settingsService;
+    return this.setup({
+      events: requestData.events,
+      channels: requestData.channels
+    });
   }
   /**
    * Complete workflow notification setup including channels and settings
@@ -5347,10 +5102,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 || {}
@@ -5358,7 +5113,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,
       {
@@ -5377,7 +5132,7 @@ var NotificationSetupService = class {
         });
       })
     );
-    debug5(
+    debug4(
       requestData.workflowId ? "Successfully setup notifications for workflow %s" : "Successfully setup notifications for workspace",
       requestData.workflowId
     );
@@ -5459,7 +5214,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
@@ -5467,7 +5222,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
@@ -5492,7 +5247,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,
@@ -5504,725 +5259,741 @@ var NotificationSetupService = class {
           name: channelName,
           config
         });
-        debug5("Created channel with custom config %O", {
+        debug4("Created channel with custom config %O", {
           workflowId,
           channelType,
           channelName,
           channel
         });
-        return channel;
-      })
-    );
-    return channels;
-  }
-};
-
-// src/internal/domains/validation/validation-core.service.ts
-var ValidationCoreService = class {
-  constructor(client) {
-    this.validationApi = new DataValidationApi(
-      client.configuration,
-      client.baseUrl,
-      client.axiosInstance
-    );
-  }
-  async listWorkflowValidations(filters) {
-    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidationsGet(
-      filters
-    );
-    if (response.status !== 200) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: "Failed to list workflow validations"
-      });
-    }
-    return response.data;
-  }
-  async getValidationDetails(validationId) {
-    const response = await this.validationApi.v4DataValidationValidationsValidationIdGet({
-      validationId
-    });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: "Failed to get validation details"
-      });
-    }
-    return response.data;
-  }
-  async scheduleValidation(workflowId, jobId) {
-    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidatePost(
-      {
-        workflowId,
-        jobId
-      }
-    );
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: response.data.message || "Failed to schedule validation"
-      });
-    }
-    return response.data;
-  }
-  async toggleValidationEnabled(workflowId) {
-    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdValidationTogglePut(
-      {
-        workflowId
-      }
-    );
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: response.data.message || "Failed to toggle validation"
-      });
-    }
-    return response.data;
-  }
-  async getLatestValidation(workflowId, jobId) {
-    let response;
-    if (jobId) {
-      response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidationsLatestGet(
-        {
-          workflowId,
-          jobId
-        }
-      );
-    } else {
-      response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdValidationsLatestGet(
-        {
-          workflowId
-        }
-      );
-    }
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: "Failed to get latest validation"
-      });
-    }
-    return response.data;
-  }
-  async getValidationAnomalies(validationId) {
-    const response = await this.validationApi.v4DataValidationValidationsValidationIdAnomaliesGet(
-      {
-        validationId
-      }
-    );
-    if (response.status !== 200) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: "Failed to get validation anomalies"
-      });
-    }
-    return response.data;
-  }
-  async getValidationAnomaliesByRule(validationId, ruleName) {
-    const response = await this.validationApi.v4DataValidationValidationsValidationIdAnomaliesRulesRuleNameGet(
-      {
-        validationId,
-        ruleName
-      }
-    );
-    if (response.status !== 200) {
-      throw KadoaHttpException.wrap(response.data, {
-        message: "Failed to get validation anomalies by rule"
-      });
-    }
-    return response.data;
-  }
-  async waitUntilCompleted(validationId, options) {
-    const result = await pollUntil(
-      async () => {
-        const current = await this.getValidationDetails(validationId);
-        if (current.error) {
-          throw new KadoaSdkException(`Validation failed: ${current.error}`, {
-            code: "VALIDATION_ERROR",
-            details: { validationId, error: current.error }
-          });
-        }
-        return current;
-      },
-      (result2) => result2.completedAt != null,
-      options
+        return channel;
+      })
     );
-    return result.result;
+    return channels;
   }
 };
-var ValidationRulesService = class {
-  constructor(client) {
-    this.validationApi = new DataValidationApi(
-      client.configuration,
-      client.baseUrl,
-      client.axiosInstance
-    );
-  }
-  async listRules(options) {
-    const response = await this.validationApi.v4DataValidationRulesGet(options);
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: "Failed to list validation rules"
-      });
+
+// 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) }
+        }
+      );
     }
-    return response.data;
+    this.teamApiKey = config.teamApiKey;
+    this.heartbeatInterval = config.heartbeatInterval || 1e4;
+    this.reconnectDelay = config.reconnectDelay || 5e3;
+    this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
   }
-  async getRuleById(ruleId) {
-    const response = await this.validationApi.v4DataValidationRulesRuleIdGet({
-      ruleId
-    });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: "Failed to get validation rule by id"
+  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);
     }
-    return response.data.data;
   }
-  async getRuleByName(name) {
-    const response = await this.validationApi.v4DataValidationRulesGet();
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: "Failed to get validation rule by name"
-      });
-    }
-    return response.data.data?.find((rule) => rule.name === name);
+  handleHeartbeat() {
+    debug5("Heartbeat received");
+    this.lastHeartbeat = Date.now();
   }
-  async createRule(data) {
-    const response = await this.validationApi.v4DataValidationRulesPost({
-      createRule: data
+  notifyEventListeners(event) {
+    this.eventListeners.forEach((listener) => {
+      try {
+        listener(event);
+      } catch (error) {
+        debug5("Error in event listener: %O", error);
+      }
     });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to create validation rule"
-      });
-    }
-    return response.data.data;
   }
-  async updateRule(ruleId, updateData) {
-    const response = await this.validationApi.v4DataValidationRulesRuleIdPut({
-      ruleId,
-      updateRule: updateData
+  notifyConnectionListeners(connected, reason) {
+    this.connectionListeners.forEach((listener) => {
+      try {
+        listener(connected, reason);
+      } catch (error) {
+        debug5("Error in connection listener: %O", error);
+      }
     });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to update validation rule"
-      });
-    }
-    return response.data.data;
-  }
-  async disableRule(data) {
-    const response = await this.validationApi.v4DataValidationRulesRuleIdDisablePost(data);
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to disable validation rule"
-      });
-    }
-    return response.data.data;
   }
-  async generateRule(data) {
-    const response = await this.validationApi.v4DataValidationRulesActionsGeneratePost({
-      generateRule: data
+  notifyErrorListeners(error) {
+    this.errorListeners.forEach((listener) => {
+      try {
+        listener(error);
+      } catch (error2) {
+        debug5("Error in error listener: %O", error2);
+      }
     });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to generate validation rule"
-      });
-    }
-    return response.data.data;
   }
-  async generateRules(data) {
-    const response = await this.validationApi.v4DataValidationRulesActionsGenerateRulesPost({
-      generateRules: data
-    });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to generate validation rules"
-      });
-    }
-    return response.data.data;
+  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);
   }
-  async bulkApproveRules(data) {
-    const response = await this.validationApi.v4DataValidationRulesActionsBulkApprovePost({
-      bulkApproveRules: data
-    });
-    if (response.status !== 200 || response.data.error) {
-      throw KadoaHttpException.wrap(response.data.data, {
-        message: response.data.message || "Failed to bulk approve validation rules"
-      });
+  stopHeartbeatCheck() {
+    if (this.missedHeartbeatCheckTimer) {
+      clearInterval(this.missedHeartbeatCheckTimer);
     }
-    return response.data.data;
   }
-  async bulkDeleteRules(data) {
-    const response = await this.validationApi.v4DataValidationRulesActionsBulkDeletePost({
-      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"
-      });
+  /**
+   * 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;
     }
-    return response.data.data;
+    this.eventListeners.clear();
+    this.connectionListeners.clear();
+    this.errorListeners.clear();
   }
-  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;
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
   }
 };
 
-// src/internal/domains/extraction/services/entity-resolver.service.ts
-var ENTITY_API_ENDPOINT = "/v4/entity";
-var EntityResolverService = class {
+// src/domains/user/user.service.ts
+var UserService = 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
+   * Get current user details
+   * @returns User details
    */
-  async resolveEntity(entityConfig, options) {
-    if (entityConfig === "ai-detection") {
-      if (!options?.link) {
-        throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
-          code: "VALIDATION_ERROR",
-          details: { entityConfig, options }
-        });
+  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 entityPrediction = await this.fetchEntityFields({
-        link: options.link,
-        location: options.location,
-        navigationMode: options.navigationMode
+    });
+    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 {
-        entity: entityPrediction.entity,
-        fields: entityPrediction.fields
+        result: current,
+        attempts,
+        duration: Date.now() - start
       };
-    } else if (entityConfig) {
-      if ("schemId" in entityConfig) {
-        const schema = await this.schemasService.getSchema(
-          entityConfig.schemId
-        );
-        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
-      }
-    });
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
   }
-  /**
-   * 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
+  throw new KadoaSdkException(
+    `Polling operation timed out after ${timeoutMs}ms`,
+    {
+      code: POLLING_ERROR_CODES.TIMEOUT,
+      details: {
+        timeoutMs,
+        attempts,
+        duration: Date.now() - start
       }
-    });
-    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];
+  );
+}
+
+// src/domains/validation/validation-core.service.ts
+var ValidationCoreService = class {
+  constructor(client) {
+    this.validationApi = new DataValidationApi(
+      client.configuration,
+      client.baseUrl,
+      client.axiosInstance
+    );
   }
-  /**
-   * Validates entity request options
-   */
-  validateEntityOptions(options) {
-    if (!options.link) {
-      throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
-        code: "VALIDATION_ERROR",
-        details: { options }
+  async listWorkflowValidations(filters) {
+    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidationsGet(
+      filters
+    );
+    if (response.status !== 200) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: "Failed to list workflow validations"
       });
     }
+    return response.data;
   }
-};
-
-// src/internal/domains/extraction/builders/extraction-builder.ts
-var ExtractionBuilder = class {
-  constructor() {
-    this.fields = [];
-  }
-  /**
-   * Start defining a custom schema with fields
-   * @param name - The entity name (e.g., "Product", "Article")
-   */
-  schema(name) {
-    if (this.schemaId) {
-      throw new KadoaSdkException(
-        "Cannot use schema() after useSchema() - they are mutually exclusive",
-        { code: "VALIDATION_ERROR" }
-      );
+  async getValidationDetails(validationId) {
+    const response = await this.validationApi.v4DataValidationValidationsValidationIdGet({
+      validationId
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: "Failed to get validation details"
+      });
     }
-    this.schemaName = name;
-    return new SchemaBuilder(this);
+    return response.data;
   }
-  /**
-   * Use an existing schema by ID
-   * @param schemaId - The schema ID to reference
-   */
-  useSchema(schemaId) {
-    if (this.schemaName || this.fields.length > 0) {
-      throw new KadoaSdkException(
-        "Cannot use useSchema() after schema() or field definitions - they are mutually exclusive",
-        { code: "VALIDATION_ERROR" }
-      );
+  async scheduleValidation(workflowId, jobId) {
+    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidatePost(
+      {
+        workflowId,
+        jobId
+      }
+    );
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: response.data.message || "Failed to schedule validation"
+      });
     }
-    this.schemaId = schemaId;
-    return this;
+    return response.data;
   }
-  /**
-   * Extract raw page content without transformation
-   * @param format - Raw content format(s): "html", "markdown", or "url"
-   */
-  raw(format) {
-    const formats = Array.isArray(format) ? format : [format];
-    const nameMap = {
-      html: "rawHtml",
-      markdown: "rawMarkdown",
-      url: "rawUrl"
-    };
-    const metadataKeyMap = {
-      html: "HTML",
-      markdown: "MARKDOWN",
-      url: "PAGE_URL"
-    };
-    for (const f of formats) {
-      const fieldName = nameMap[f];
-      if (this.fields.some((field) => field.name === fieldName)) {
-        continue;
+  async toggleValidationEnabled(workflowId) {
+    const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdValidationTogglePut(
+      {
+        workflowId
       }
-      this.fields.push({
-        name: fieldName,
-        description: `Raw page content in ${f.toUpperCase()} format`,
-        fieldType: "METADATA",
-        metadataKey: metadataKeyMap[f]
+    );
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: response.data.message || "Failed to toggle validation"
       });
     }
-    return this;
-  }
-  /**
-   * Get the fields array (internal use)
-   */
-  getFields() {
-    return this.fields;
-  }
-  /**
-   * Get the schema name (internal use)
-   */
-  getSchemaName() {
-    return this.schemaName;
-  }
-  /**
-   * Get the schema ID (internal use)
-   */
-  getSchemaId() {
-    return this.schemaId;
-  }
-};
-var _SchemaBuilder = class _SchemaBuilder extends ExtractionBuilder {
-  constructor(parentBuilder) {
-    super();
-    this.fields = parentBuilder.getFields();
-    this.schemaName = parentBuilder.getSchemaName();
-    this.schemaId = parentBuilder.getSchemaId();
+    return response.data;
   }
-  /**
-   * 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) {
-    if (!_SchemaBuilder.FIELD_NAME_PATTERN.test(name)) {
-      throw new KadoaSdkException(
-        `Field name "${name}" must be alphanumeric only (no underscores or special characters)`,
+  async getLatestValidation(workflowId, jobId) {
+    let response;
+    if (jobId) {
+      response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidationsLatestGet(
+        {
+          workflowId,
+          jobId
+        }
+      );
+    } else {
+      response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdValidationsLatestGet(
         {
-          code: "VALIDATION_ERROR",
-          details: { name, pattern: "^[A-Za-z0-9]+$" }
+          workflowId
         }
       );
     }
-    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 }
+    if (response.status !== 200 || response.data?.error) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: "Failed to get latest validation"
       });
     }
-    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;
+    return response.data;
   }
-  /**
-   * 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) {
-    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]+$" }
-        }
-      );
+  async getValidationAnomalies(validationId) {
+    const response = await this.validationApi.v4DataValidationValidationsValidationIdAnomaliesGet(
+      {
+        validationId
+      }
+    );
+    if (response.status !== 200) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: "Failed to get validation anomalies"
+      });
     }
-    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 }
+    return response.data;
+  }
+  async getValidationAnomaliesByRule(validationId, ruleName) {
+    const response = await this.validationApi.v4DataValidationValidationsValidationIdAnomaliesRulesRuleNameGet(
+      {
+        validationId,
+        ruleName
+      }
+    );
+    if (response.status !== 200) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: "Failed to get validation anomalies by rule"
       });
     }
-    this.fields.push({
-      name,
-      description,
-      fieldType: "CLASSIFICATION",
-      categories
-    });
-    return this;
+    return response.data;
   }
-  /**
-   * Add raw page content alongside structured fields
-   * @param format - Raw content format(s): "html", "markdown", or "url"
-   */
-  raw(format) {
-    return super.raw(format);
+  async waitUntilCompleted(validationId, options) {
+    const result = await pollUntil(
+      async () => {
+        const current = await this.getValidationDetails(validationId);
+        if (current.error) {
+          throw new KadoaSdkException(`Validation failed: ${current.error}`, {
+            code: "VALIDATION_ERROR",
+            details: { validationId, error: current.error }
+          });
+        }
+        return current;
+      },
+      (result2) => result2.completedAt != null,
+      options
+    );
+    return result.result;
   }
 };
-_SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
-_SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
-  "STRING",
-  "IMAGE",
-  "LINK",
-  "OBJECT",
-  "ARRAY"
-];
-var SchemaBuilder = _SchemaBuilder;
-
-// src/internal/domains/extraction/services/extraction-builder.service.ts
-var debug7 = logger.extraction;
-var ExtractionBuilderService = class {
-  constructor(workflowsCoreService, entityResolverService, dataFetcherService, notificationSetupService) {
-    this.workflowsCoreService = workflowsCoreService;
-    this.entityResolverService = entityResolverService;
-    this.dataFetcherService = dataFetcherService;
-    this.notificationSetupService = notificationSetupService;
+var ValidationRulesService = class {
+  constructor(client) {
+    this.validationApi = new DataValidationApi(
+      client.configuration,
+      client.baseUrl,
+      client.axiosInstance
+    );
   }
-  get options() {
-    assert__default.default(this._options, "Options are not set");
-    return this._options;
+  async listRules(options) {
+    const response = await this.validationApi.v4DataValidationRulesGet(options);
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: "Failed to list validation rules"
+      });
+    }
+    return response.data;
   }
-  get notificationOptions() {
-    return this._notificationOptions;
+  async getRuleById(ruleId) {
+    const response = await this.validationApi.v4DataValidationRulesRuleIdGet({
+      ruleId
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: "Failed to get validation rule by id"
+      });
+    }
+    return response.data.data;
   }
-  get monitoringOptions() {
-    return this._monitoringOptions;
+  async getRuleByName(name) {
+    const response = await this.validationApi.v4DataValidationRulesGet();
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: "Failed to get validation rule by name"
+      });
+    }
+    return response.data.data?.find((rule) => rule.name === name);
   }
-  get workflowId() {
-    assert__default.default(this._workflowId, "Workflow ID is not set");
-    return this._workflowId;
+  async createRule(data) {
+    const response = await this.validationApi.v4DataValidationRulesPost({
+      createRule: data
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to create validation rule"
+      });
+    }
+    return response.data.data;
   }
-  get jobId() {
-    assert__default.default(this._jobId, "Job ID is not set");
-    return this._jobId;
+  async updateRule(ruleId, updateData) {
+    const response = await this.validationApi.v4DataValidationRulesRuleIdPut({
+      ruleId,
+      updateRule: updateData
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to update validation rule"
+      });
+    }
+    return response.data.data;
   }
-  extract({
-    urls,
-    name,
-    description,
-    navigationMode,
-    extraction
-  }) {
-    let entity = "ai-detection";
-    if (extraction) {
-      const builder = extraction(new ExtractionBuilder());
-      const schemaId = builder.getSchemaId();
-      const schemaName = builder.getSchemaName();
-      const fields = builder.getFields();
-      if (schemaId) {
-        entity = { schemId: schemaId };
-      } else if (schemaName && fields.length > 0) {
-        entity = { name: schemaName, fields };
-      } else if (fields.length > 0 && !schemaName) {
-        entity = { name: "RawExtraction", fields };
-      } else {
-        entity = "ai-detection";
-      }
+  async disableRule(data) {
+    const response = await this.validationApi.v4DataValidationRulesRuleIdDisablePost(data);
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to disable validation rule"
+      });
     }
-    this._options = {
-      urls,
-      name,
-      description,
-      navigationMode: navigationMode || "single-page",
-      entity,
-      bypassPreview: false
-    };
-    return this;
+    return response.data.data;
   }
-  withNotifications(options) {
-    this._notificationOptions = options;
-    return this;
+  async generateRule(data) {
+    const response = await this.validationApi.v4DataValidationRulesActionsGeneratePost({
+      generateRule: data
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to generate validation rule"
+      });
+    }
+    return response.data.data;
   }
-  withMonitoring(options) {
-    this._monitoringOptions = options;
-    return this;
+  async generateRules(data) {
+    const response = await this.validationApi.v4DataValidationRulesActionsGenerateRulesPost({
+      generateRules: data
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to generate validation rules"
+      });
+    }
+    return response.data.data;
   }
-  bypassPreview() {
-    assert__default.default(this._options, "Options are not set");
-    this._options.bypassPreview = true;
-    return this;
+  async bulkApproveRules(data) {
+    const response = await this.validationApi.v4DataValidationRulesActionsBulkApprovePost({
+      bulkApproveRules: data
+    });
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data.data, {
+        message: response.data.message || "Failed to bulk approve validation rules"
+      });
+    }
+    return response.data.data;
   }
-  setInterval(options) {
-    assert__default.default(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;
+  async bulkDeleteRules(data) {
+    const response = await this.validationApi.v4DataValidationRulesActionsBulkDeletePost({
+      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 this;
-  }
-  setLocation(options) {
-    assert__default.default(this._options, "Options are not set");
-    this._options.location = options;
-    return this;
+    return response.data.data;
   }
-  async create() {
-    assert__default.default(this._options, "Options are not set");
-    const { urls, name, description, navigationMode, entity } = this.options;
-    const resolvedEntity = typeof entity === "object" && "schemId" 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" && "schemId" in entity ? entity.schemId : 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__default.default(this._options, "Options are not set");
-    assert__default.default(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__default.default(this._options, "Options are not set");
-    assert__default.default(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__default.default(this._workflowId, "Workflow ID is not set");
-    assert__default.default(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__default.default(this._jobId, "Job ID is not set");
-    assert__default.default(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) {
@@ -6299,7 +6070,9 @@ var KadoaClient = class {
       workflowsCoreService,
       dataFetcherService,
       entityResolverService,
-      channelSetupService
+      channelSetupService,
+      channelsService,
+      settingsService
     );
     this._extractionBuilderService = new ExtractionBuilderService(
       workflowsCoreService,
@@ -6307,22 +6080,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();
     }
@@ -6461,12 +6231,28 @@ var KadoaClient = class {
   }
 };
 
+exports.DataFetcherService = DataFetcherService;
 exports.ERROR_MESSAGES = ERROR_MESSAGES;
+exports.EntityResolverService = EntityResolverService;
+exports.ExtractionBuilderService = ExtractionBuilderService;
+exports.ExtractionService = ExtractionService;
+exports.FetchDataOptions = FetchDataOptions;
 exports.KadoaClient = KadoaClient;
 exports.KadoaHttpException = KadoaHttpException;
 exports.KadoaSdkException = KadoaSdkException;
-exports.SchemasModule = SchemasModule;
-exports.ValidationModule = ValidationModule;
+exports.NotificationChannelType = NotificationChannelType;
+exports.NotificationChannelsService = NotificationChannelsService;
+exports.NotificationSettingsEventTypeEnum = V5NotificationsSettingsGetEventTypeEnum;
+exports.NotificationSettingsService = NotificationSettingsService;
+exports.NotificationSetupService = NotificationSetupService;
+exports.Realtime = Realtime;
+exports.SchemaBuilder = SchemaBuilder;
+exports.SchemaFieldDataType = SchemaFieldDataType;
+exports.SchemasService = SchemasService;
+exports.UserService = UserService;
+exports.ValidationCoreService = ValidationCoreService;
+exports.ValidationRulesService = ValidationRulesService;
+exports.WorkflowsCoreService = WorkflowsCoreService;
 exports.pollUntil = pollUntil;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map