@kadoa/node-sdk 0.19.4-beta.3 → 0.20.2

package/dist/index.js

@@ -3614,7 +3614,7 @@ var WorkflowsApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * Resumes a paused, preview, or error workflow. If the user\'s team/organization or any of the user\'s organizations has the COMPLIANCE_REVIEW rule enabled, the workflow will be sent for compliance review instead of being directly activated.
+     * Resumes/Activates a paused, preview, or error workflow.
      * @summary Resume a workflow
      * @param {string} workflowId The ID of the workflow to resume
      * @param {*} [options] Override http request option.
@@ -4065,7 +4065,7 @@ var WorkflowsApiFp = function(configuration) {
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios3__default.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * Resumes a paused, preview, or error workflow. If the user\'s team/organization or any of the user\'s organizations has the COMPLIANCE_REVIEW rule enabled, the workflow will be sent for compliance review instead of being directly activated.
+     * Resumes/Activates a paused, preview, or error workflow.
      * @summary Resume a workflow
      * @param {string} workflowId The ID of the workflow to resume
      * @param {*} [options] Override http request option.
@@ -4300,7 +4300,7 @@ var WorkflowsApi = class extends BaseAPI {
     return WorkflowsApiFp(this.configuration).v4WorkflowsWorkflowIdPausePut(requestParameters.workflowId, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * Resumes a paused, preview, or error workflow. If the user\'s team/organization or any of the user\'s organizations has the COMPLIANCE_REVIEW rule enabled, the workflow will be sent for compliance review instead of being directly activated.
+   * Resumes/Activates a paused, preview, or error workflow.
    * @summary Resume a workflow
    * @param {WorkflowsApiV4WorkflowsWorkflowIdResumePutRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
@@ -4409,6 +4409,122 @@ var DataFieldDataTypeEnum = {
   Array: "ARRAY"
 };
 
+// src/domains/crawler/crawler.acl.ts
+var PageStatus = {
+  Done: "DONE",
+  Crawling: "CRAWLING",
+  Pending: "PENDING"
+};
+
+// src/domains/crawler/crawler-config.service.ts
+var CrawlerConfigService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get api() {
+    return this.client.apis.crawler;
+  }
+  async createConfig(body) {
+    const response = await this.api.v4CrawlConfigPost({
+      createCrawlerConfigRequest: body
+    });
+    return response.data;
+  }
+  async getConfig(configId) {
+    const response = await this.api.v4CrawlConfigConfigIdGet({ configId });
+    return response.data;
+  }
+  async deleteConfig(configId) {
+    const response = await this.api.v4CrawlConfigDelete({
+      deleteCrawlerConfigRequest: { configId }
+    });
+    return response.data;
+  }
+};
+
+// src/domains/crawler/crawler-session.service.ts
+var CrawlerSessionService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get api() {
+    return this.client.apis.crawler;
+  }
+  async start(body) {
+    const response = await this.api.v4CrawlPost({
+      startCrawlerSessionRequest: body
+    });
+    return response.data;
+  }
+  async startWithConfig(body) {
+    const response = await this.api.v4CrawlStartPost({
+      startSessionWithConfigRequest: body
+    });
+    return response.data;
+  }
+  async pause(sessionId) {
+    const response = await this.api.v4CrawlPausePost({
+      pauseCrawlerSessionRequest: { sessionId }
+    });
+    return response.data;
+  }
+  async resume(sessionId) {
+    const response = await this.api.v4CrawlResumePost({
+      resumeCrawlerSessionRequest: { sessionId }
+    });
+    return response.data;
+  }
+  async listSessions(options) {
+    const response = await this.api.v4CrawlSessionsGet({
+      page: options?.page,
+      pageSize: options?.pageSize,
+      userId: options?.userId
+    });
+    return response.data.data ?? [];
+  }
+  async getSessionStatus(sessionId) {
+    const response = await this.api.v4CrawlSessionIdStatusGet({ sessionId });
+    return response.data;
+  }
+  async getPages(sessionId, options) {
+    const response = await this.api.v4CrawlSessionIdPagesGet({
+      sessionId,
+      currentPage: options?.currentPage,
+      pageSize: options?.pageSize
+    });
+    return response.data;
+  }
+  async getPage(sessionId, pageId, options) {
+    const response = await this.api.v4CrawlSessionIdPagesPageIdGet({
+      sessionId,
+      pageId,
+      format: options?.format
+    });
+    return response.data;
+  }
+  async getAllSessionData(sessionId, options) {
+    const response = await this.api.v4CrawlSessionIdListGet({
+      sessionId,
+      includeAll: options?.includeAll
+    });
+    return response.data;
+  }
+  async getBucketFile(filenameb64) {
+    const response = await this.api.v4CrawlBucketDataFilenameb64Get({
+      filenameb64
+    });
+    return response.data;
+  }
+};
+
+// src/domains/crawler/crawler.facade.ts
+function createCrawlerDomain(client) {
+  return {
+    config: new CrawlerConfigService(client),
+    session: new CrawlerSessionService(client)
+  };
+}
+
 // src/domains/extraction/extraction.acl.ts
 var FetchDataOptions = class {
 };
@@ -4529,7 +4645,6 @@ var DataFetcherService = class {
 
 // src/runtime/exceptions/base.exception.ts
 var KadoaErrorCode = {
-  AUTH_ERROR: "AUTH_ERROR",
   VALIDATION_ERROR: "VALIDATION_ERROR",
   BAD_REQUEST: "BAD_REQUEST",
   NOT_FOUND: "NOT_FOUND",
@@ -4649,8 +4764,7 @@ var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
       endpoint: url,
       method,
       responseBody: error.response?.data,
-      details: extra?.details,
-      cause: error
+      details: extra?.details
     });
   }
   toJSON() {
@@ -4836,7 +4950,10 @@ var SchemaBuilder = _SchemaBuilder;
 var debug = logger.schemas;
 var SchemasService = class {
   constructor(client) {
-    this.schemasApi = new SchemasApi(client.configuration);
+    this.client = client;
+  }
+  get schemasApi() {
+    return this.client.apis.schemas;
   }
   /**
    * Create a schema builder with fluent API and inline create support.
@@ -5406,15 +5523,18 @@ var ExtractionBuilderService = class {
         selectorMode: useSelectorMode
       });
     }
+    const hasSchemaId = typeof entity === "object" && "schemaId" in entity && entity.schemaId;
     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,
+      ...hasSchemaId ? {
+        schemaId: entity.schemaId,
+        entity: resolvedEntity.entity,
+        fields: resolvedEntity.fields
+      } : { entity: resolvedEntity.entity, fields: resolvedEntity.fields },
       autoStart: false,
       interval: this._options.interval,
       schedules: this._options.schedules,
@@ -5607,11 +5727,14 @@ var _NotificationChannelsService = class _NotificationChannelsService {
   }
   async createChannel(type, config) {
     const payload = await this.buildPayload(
-      esToolkit.merge(config || {}, {
-        name: _NotificationChannelsService.DEFAULT_CHANNEL_NAME,
-        channelType: type,
-        config: {}
-      })
+      esToolkit.merge(
+        {
+          name: _NotificationChannelsService.DEFAULT_CHANNEL_NAME,
+          channelType: type,
+          config: {}
+        },
+        config || {}
+      )
     );
     const response = await this.api.v5NotificationsChannelsPost({
       v5NotificationsChannelsPostRequest: payload
@@ -5717,6 +5840,19 @@ var NotificationSettingsService = class {
   async listAllEvents() {
     return Object.values(V5NotificationsSettingsGetEventTypeEnum);
   }
+  async updateSettings(settingsId, data) {
+    const response = await this.api.v5NotificationsSettingsSettingsIdPut({
+      settingsId,
+      v5NotificationsSettingsSettingsIdPutRequest: data
+    });
+    const settings = response.data.data?.settings;
+    if (!settings) {
+      throw KadoaHttpException.wrap(response, {
+        message: "Failed to update notification settings"
+      });
+    }
+    return settings;
+  }
   async deleteSettings(settingsId) {
     const response = await this.api.v5NotificationsSettingsSettingsIdDelete({
       settingsId
@@ -5737,20 +5873,10 @@ var NotificationSetupService = class {
     this.settingsService = settingsService;
   }
   /**
-   * Setup notification settings for a specific workflow ensuring no duplicates exist.
+   * Setup notification settings for a specific workflow.
+   * Creates channels and settings for the specified events.
    */
   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.setup({
       workflowId: requestData.workflowId,
       events: requestData.events,
@@ -5798,8 +5924,24 @@ var NotificationSetupService = class {
         channels: channelIds
       }
     );
+    const existingSettings = await this.settingsService.listSettings({
+      workflowId: requestData.workflowId
+    });
     const newSettings = await Promise.all(
       eventTypes.map(async (eventType) => {
+        const existing = existingSettings.find(
+          (s) => s.eventType === eventType
+        );
+        if (existing?.id) {
+          const existingChannelIds = (existing.channels || []).map((c) => c.id).filter(Boolean);
+          const mergedChannelIds = [
+            .../* @__PURE__ */ new Set([...existingChannelIds, ...channelIds])
+          ];
+          return await this.settingsService.updateSettings(existing.id, {
+            channelIds: mergedChannelIds,
+            enabled: existing.enabled ?? true
+          });
+        }
         return await this.settingsService.createSettings({
           workflowId: requestData.workflowId,
           channelIds,
@@ -5932,9 +6074,10 @@ var NotificationSetupService = class {
           });
           return existingChannel;
         }
+        const { name: _, ...channelConfig } = config;
         const channel = await this.channelsService.createChannel(channelType, {
           name: channelName,
-          config
+          config: channelConfig
         });
         debug4("Created channel with custom config %O", {
           workflowId,
@@ -5952,10 +6095,11 @@ var NotificationSetupService = class {
 // 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";
+process.env.KADOA_WSS_NEO_API_URI ?? "wss://events.kadoa.com/events/ws";
 var REALTIME_API_URI = process.env.KADOA_REALTIME_API_URI ?? "https://realtime.kadoa.com";
 
 // src/version.ts
-var SDK_VERSION = "0.19.3";
+var SDK_VERSION = "0.20.2";
 var SDK_NAME = "kadoa-node-sdk";
 var SDK_LANGUAGE = "node";
 
@@ -5975,7 +6119,6 @@ var Realtime = class {
     this.heartbeatInterval = config.heartbeatInterval || 1e4;
     this.reconnectDelay = config.reconnectDelay || 5e3;
     this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
-    this.source = config.source;
   }
   async connect() {
     if (this.isConnecting) return;
@@ -5990,56 +6133,59 @@ var Realtime = class {
         }
       });
       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,
-              ...this.source && { source: this.source }
-            })
-          );
-          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 })
-              });
+      await new Promise((resolve, reject) => {
+        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();
+          resolve();
+        };
+        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);
             }
-            this.notifyEventListeners(data);
+          } catch (err) {
+            debug5("Failed to parse incoming message: %O", err);
           }
-        } 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);
-      };
+        };
+        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);
+          reject(error);
+        };
+      });
     } catch (err) {
       debug5("Failed to connect: %O", err);
       this.isConnecting = false;
@@ -6282,11 +6428,10 @@ function isNewerVersion(version1, version2) {
 // src/domains/validation/validation-core.service.ts
 var ValidationCoreService = class {
   constructor(client) {
-    this.validationApi = new DataValidationApi(
-      client.configuration,
-      client.baseUrl,
-      client.axiosInstance
-    );
+    this.client = client;
+  }
+  get validationApi() {
+    return this.client.apis.validation;
   }
   async listWorkflowValidations(filters) {
     const response = await this.validationApi.v4DataValidationWorkflowsWorkflowIdJobsJobIdValidationsGet(
@@ -6388,6 +6533,7 @@ var ValidationCoreService = class {
     return response.data;
   }
   async waitUntilCompleted(validationId, options) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
     const result = await pollUntil(
       async () => {
         const current = await this.getValidationDetails(validationId);
@@ -6407,11 +6553,10 @@ var ValidationCoreService = class {
 };
 var ValidationRulesService = class {
   constructor(client) {
-    this.validationApi = new DataValidationApi(
-      client.configuration,
-      client.baseUrl,
-      client.axiosInstance
-    );
+    this.client = client;
+  }
+  get validationApi() {
+    return this.client.apis.validation;
   }
   async listRules(options) {
     const response = await this.validationApi.v4DataValidationRulesGet(options);
@@ -6465,6 +6610,25 @@ var ValidationRulesService = class {
     }
     return response.data.data;
   }
+  async deleteRule(data) {
+    const response = await this.validationApi.v4DataValidationRulesRuleIdDelete(
+      {
+        ruleId: data.ruleId,
+        ...data.workflowId != null && {
+          deleteRuleWithReason: {
+            workflowId: data.workflowId,
+            ...data.reason != null && { reason: data.reason }
+          }
+        }
+      }
+    );
+    if (response.status !== 200 || response.data.error) {
+      throw KadoaHttpException.wrap(response.data, {
+        message: response.data.message || "Failed to delete validation rule"
+      });
+    }
+    return response.data;
+  }
   async disableRule(data) {
     const response = await this.validationApi.v4DataValidationRulesRuleIdDisablePost(data);
     if (response.status !== 200 || response.data.error) {
@@ -6588,7 +6752,8 @@ var WorkflowsCoreService = class {
         location: input.location,
         autoStart: input.autoStart,
         schedules: input.schedules,
-        additionalData: input.additionalData
+        additionalData: input.additionalData,
+        limit: input.limit
       };
       const response2 = await this.workflowsApi.v4WorkflowsPost({
         createWorkflowBody: agenticRequest
@@ -6610,7 +6775,7 @@ var WorkflowsCoreService = class {
       schemaId: input.schemaId,
       description: input.description,
       navigationMode: input.navigationMode,
-      entity: input.entity ?? "",
+      ...input.entity != null && { entity: input.entity },
       fields: input.fields,
       bypassPreview: input.bypassPreview ?? true,
       tags: input.tags,
@@ -6619,7 +6784,8 @@ var WorkflowsCoreService = class {
       location: input.location,
       autoStart: input.autoStart,
       schedules: input.schedules,
-      additionalData: input.additionalData
+      additionalData: input.additionalData,
+      limit: input.limit
     };
     const response = await this.workflowsApi.v4WorkflowsPost({
       createWorkflowBody: request
@@ -6753,131 +6919,44 @@ var WorkflowsCoreService = class {
   }
 };
 
-// src/domains/crawler/crawler-config.service.ts
-var CrawlerConfigService = class {
-  constructor(client) {
-    this.client = client;
-    this._api = null;
-  }
-  get api() {
-    if (!this._api) {
-      this._api = new CrawlerApi(
-        this.client.configuration,
-        this.client.baseUrl,
-        this.client.axiosInstance
-      );
-    }
-    return this._api;
-  }
-  async createConfig(body) {
-    const response = await this.api.v4CrawlConfigPost({
-      createCrawlerConfigRequest: body
-    });
-    return response.data;
-  }
-  async getConfig(configId) {
-    const response = await this.api.v4CrawlConfigConfigIdGet({ configId });
-    return response.data;
-  }
-  async deleteConfig(configId) {
-    const response = await this.api.v4CrawlConfigDelete({
-      deleteCrawlerConfigRequest: { configId }
+// src/client/api-registry.ts
+var ApiRegistry = class {
+  constructor(apiKey, baseUrl, axios2, headers) {
+    this.baseUrl = baseUrl;
+    this.axios = axios2;
+    this.cache = /* @__PURE__ */ new Map();
+    this.configuration = new Configuration({
+      apiKey,
+      basePath: baseUrl,
+      baseOptions: { headers }
     });
-    return response.data;
-  }
-};
-
-// src/domains/crawler/crawler-session.service.ts
-var CrawlerSessionService = class {
-  constructor(client) {
-    this.client = client;
-    this._api = null;
   }
-  get api() {
-    if (!this._api) {
-      this._api = new CrawlerApi(
-        this.client.configuration,
-        this.client.baseUrl,
-        this.client.axiosInstance
+  get(ApiClass) {
+    if (!this.cache.has(ApiClass)) {
+      this.cache.set(
+        ApiClass,
+        new ApiClass(this.configuration, this.baseUrl, this.axios)
       );
     }
-    return this._api;
-  }
-  async start(body) {
-    const response = await this.api.v4CrawlPost({
-      startCrawlerSessionRequest: body
-    });
-    return response.data;
-  }
-  async startWithConfig(body) {
-    const response = await this.api.v4CrawlStartPost({
-      startSessionWithConfigRequest: body
-    });
-    return response.data;
-  }
-  async pause(sessionId) {
-    const response = await this.api.v4CrawlPausePost({
-      pauseCrawlerSessionRequest: { sessionId }
-    });
-    return response.data;
-  }
-  async resume(sessionId) {
-    const response = await this.api.v4CrawlResumePost({
-      resumeCrawlerSessionRequest: { sessionId }
-    });
-    return response.data;
-  }
-  async listSessions(options) {
-    const response = await this.api.v4CrawlSessionsGet({
-      page: options?.page,
-      pageSize: options?.pageSize,
-      userId: options?.userId
-    });
-    return response.data.data ?? [];
+    return this.cache.get(ApiClass);
   }
-  async getSessionStatus(sessionId) {
-    const response = await this.api.v4CrawlSessionIdStatusGet({ sessionId });
-    return response.data;
+  get schemas() {
+    return this.get(SchemasApi);
   }
-  async getPages(sessionId, options) {
-    const response = await this.api.v4CrawlSessionIdPagesGet({
-      sessionId,
-      currentPage: options?.currentPage,
-      pageSize: options?.pageSize
-    });
-    return response.data;
+  get validation() {
+    return this.get(DataValidationApi);
   }
-  async getPage(sessionId, pageId, options) {
-    const response = await this.api.v4CrawlSessionIdPagesPageIdGet({
-      sessionId,
-      pageId,
-      format: options?.format
-    });
-    return response.data;
+  get crawler() {
+    return this.get(CrawlerApi);
   }
-  async getAllSessionData(sessionId, options) {
-    const response = await this.api.v4CrawlSessionIdListGet({
-      sessionId,
-      includeAll: options?.includeAll
-    });
-    return response.data;
+  get workflows() {
+    return this.get(WorkflowsApi);
   }
-  async getBucketFile(filenameb64) {
-    const response = await this.api.v4CrawlBucketDataFilenameb64Get({
-      filenameb64
-    });
-    return response.data;
+  get notifications() {
+    return this.get(NotificationsApi);
   }
 };
 
-// src/domains/crawler/crawler.facade.ts
-function createCrawlerDomain(client) {
-  return {
-    config: new CrawlerConfigService(client),
-    session: new CrawlerSessionService(client)
-  };
-}
-
 // src/domains/validation/validation.facade.ts
 function createValidationDomain(core, rules) {
   return {
@@ -6893,121 +6972,154 @@ function createValidationDomain(core, rules) {
   };
 }
 
-// src/kadoa-client.ts
-var KadoaClient = class {
-  constructor(config) {
-    this._baseUrl = PUBLIC_API_URI;
-    this._timeout = config.timeout || 3e4;
-    this._apiKey = config.apiKey;
-    const headers = {
-      "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
-      "X-SDK-Version": SDK_VERSION,
-      "X-SDK-Language": SDK_LANGUAGE
-    };
-    this._configuration = new Configuration({
-      apiKey: this._apiKey,
-      basePath: this._baseUrl,
-      baseOptions: {
-        headers
-      }
-    });
-    this._axiosInstance = globalAxios3__default.default.create({
-      timeout: this._timeout,
-      headers
-    });
-    this._axiosInstance.interceptors.request.use((config2) => {
-      config2.headers["x-request-id"] = uuid.v4();
-      return config2;
-    });
-    this._axiosInstance.interceptors.response.use(
-      (response) => {
-        if (response.status === 401) {
-          throw new KadoaHttpException("Unauthorized", {
-            code: KadoaErrorCode.AUTH_ERROR,
-            httpStatus: 401
-          });
+// src/client/wiring.ts
+function createSdkHeaders() {
+  return {
+    "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
+    "X-SDK-Version": SDK_VERSION,
+    "X-SDK-Language": SDK_LANGUAGE
+  };
+}
+function createAxiosInstance(params) {
+  const axiosInstance = globalAxios3__default.default.create({
+    timeout: params.timeout,
+    headers: params.headers
+  });
+  axiosInstance.interceptors.request.use((config) => {
+    config.headers["x-request-id"] = uuid.v4();
+    return config;
+  });
+  axiosInstance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (error instanceof globalAxios3.AxiosError) {
+        const status = error.response?.status;
+        if (status === 401 || status === 403) {
+          throw KadoaHttpException.wrap(error, { message: "Unauthorized" });
         }
-        return response;
-      },
-      (error) => {
-        if (error instanceof globalAxios3.AxiosError) {
-          const status = error.response?.status;
-          if (status === 400) {
-            throw KadoaHttpException.wrap(error);
+      }
+      throw KadoaHttpException.wrap(error);
+    }
+  );
+  return axiosInstance;
+}
+function createClientDomains(params) {
+  const { client } = params;
+  const userService = new UserService(client);
+  const dataFetcherService = new DataFetcherService(client.apis.workflows);
+  const channelsService = new NotificationChannelsService(
+    client.apis.notifications,
+    userService
+  );
+  const settingsService = new NotificationSettingsService(
+    client.apis.notifications
+  );
+  const entityResolverService = new EntityResolverService(client);
+  const workflowsCoreService = new WorkflowsCoreService(client.apis.workflows);
+  const schemasService = new SchemasService(client);
+  const channelSetupService = new NotificationSetupService(
+    channelsService,
+    settingsService
+  );
+  const coreService = new ValidationCoreService(client);
+  const rulesService = new ValidationRulesService(client);
+  const extractionService = new ExtractionService(
+    workflowsCoreService,
+    dataFetcherService,
+    entityResolverService,
+    channelSetupService,
+    channelsService,
+    settingsService
+  );
+  const extractionBuilderService = new ExtractionBuilderService(
+    workflowsCoreService,
+    entityResolverService,
+    dataFetcherService,
+    channelSetupService
+  );
+  const notification = createNotificationDomain({
+    notificationsApi: client.apis.notifications,
+    channelsService,
+    settingsService,
+    channelSetupService
+  });
+  const validation = createValidationDomain(coreService, rulesService);
+  const crawler = createCrawlerDomain(client);
+  return {
+    extractionBuilderService,
+    extraction: extractionService,
+    workflow: workflowsCoreService,
+    notification,
+    schema: schemasService,
+    user: userService,
+    validation,
+    crawler
+  };
+}
+function createNotificationDomain(params) {
+  const {
+    notificationsApi,
+    channelsService,
+    settingsService,
+    channelSetupService
+  } = params;
+  return {
+    channels: channelsService,
+    settings: settingsService,
+    setup: channelSetupService,
+    configure: (options) => channelSetupService.setup(options),
+    setupForWorkflow: (request) => channelSetupService.setupForWorkflow(request),
+    setupForWorkspace: (request) => channelSetupService.setupForWorkspace(request),
+    testNotification: async (request) => {
+      const response = await notificationsApi.v5NotificationsTestPost({
+        v5NotificationsTestPostRequest: {
+          eventType: request.eventType,
+          ...request.workflowId != null && {
+            workflowId: request.workflowId
           }
         }
-        throw KadoaHttpException.wrap(error);
+      });
+      const data = response.data.data;
+      if (!data?.eventId || !data?.eventType) {
+        throw KadoaHttpException.wrap(response, {
+          message: "Failed to test notification"
+        });
       }
-    );
-    const workflowsApi = new WorkflowsApi(
-      this.configuration,
-      this.baseUrl,
-      this.axiosInstance
-    );
-    const notificationsApi = new NotificationsApi(
-      this.configuration,
-      this.baseUrl,
-      this.axiosInstance
-    );
-    const userService = new UserService(this);
-    const dataFetcherService = new DataFetcherService(workflowsApi);
-    const channelsService = new NotificationChannelsService(
-      notificationsApi,
-      userService
-    );
-    const settingsService = new NotificationSettingsService(notificationsApi);
-    const entityResolverService = new EntityResolverService(this);
-    const workflowsCoreService = new WorkflowsCoreService(workflowsApi);
-    const schemasService = new SchemasService(this);
-    const channelSetupService = new NotificationSetupService(
-      channelsService,
-      settingsService
-    );
-    const coreService = new ValidationCoreService(this);
-    const rulesService = new ValidationRulesService(this);
-    const extractionService = new ExtractionService(
-      workflowsCoreService,
-      dataFetcherService,
-      entityResolverService,
-      channelSetupService,
-      channelsService,
-      settingsService
-    );
-    this._extractionBuilderService = new ExtractionBuilderService(
-      workflowsCoreService,
-      entityResolverService,
-      dataFetcherService,
-      channelSetupService
-    );
-    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);
-    this.crawler = createCrawlerDomain(this);
-    this._realtimeConfig = config.realtimeConfig;
-    if (config.enableRealtime && config.realtimeConfig?.autoConnect !== false) {
-      this.connectRealtime();
+      return {
+        eventId: data.eventId,
+        eventType: data.eventType,
+        ...data.workflowId != null && { workflowId: data.workflowId }
+      };
     }
+  };
+}
+
+// src/client/kadoa-client.ts
+var KadoaClient = class {
+  constructor(config) {
+    this._baseUrl = config.baseUrl ?? PUBLIC_API_URI;
+    this._apiKey = config.apiKey;
+    const timeout = config.timeout ?? 3e4;
+    const headers = createSdkHeaders();
+    this._axiosInstance = createAxiosInstance({ timeout, headers });
+    this.apis = new ApiRegistry(
+      this._apiKey,
+      this._baseUrl,
+      this._axiosInstance,
+      headers
+    );
+    const domains = createClientDomains({ client: this });
+    this.user = domains.user;
+    this.extraction = domains.extraction;
+    this.workflow = domains.workflow;
+    this.schema = domains.schema;
+    this.notification = domains.notification;
+    this.validation = domains.validation;
+    this.crawler = domains.crawler;
+    this._extractionBuilderService = domains.extractionBuilderService;
     checkForUpdates().catch(() => {
     });
   }
-  /**
-   * Get the underlying configuration
-   *
-   * @returns The configuration object
-   */
-  get configuration() {
-    return this._configuration;
-  }
   /**
    * Get the axios instance
    *
@@ -7032,14 +7144,6 @@ var KadoaClient = class {
   get apiKey() {
     return this._apiKey;
   }
-  /**
-   * Get the timeout value
-   *
-   * @returns The timeout in milliseconds
-   */
-  get timeout() {
-    return this._timeout;
-  }
   /**
    * Get the realtime connection (if enabled)
    */
@@ -7051,35 +7155,6 @@ var KadoaClient = class {
    *
    * @param options - Extraction options including URLs and optional extraction builder
    * @returns PreparedExtraction that can be configured with notifications, monitoring, etc.
-   *
-   * @example Auto-detection
-   * ```typescript
-   * const extraction = await client.extract({
-   *   urls: ["https://example.com"],
-   *   name: "My Extraction"
-   * }).create();
-   * ```
-   *
-   * @example Raw extraction
-   * ```typescript
-   * const extraction = await client.extract({
-   *   urls: ["https://example.com"],
-   *   name: "My Extraction",
-   *   extraction: builder => builder.raw("markdown")
-   * }).create();
-   * ```
-   *
-   * @example Custom schema
-   * ```typescript
-   * const extraction = await client.extract({
-   *   urls: ["https://example.com"],
-   *   name: "My Extraction",
-   *   extraction: builder => builder
-   *     .schema("Product")
-   *     .field("title", "Product name", "STRING", { example: "Example" })
-   *     .field("price", "Product price", "CURRENCY")
-   * }).create();
-   * ```
    */
   extract(options) {
     return this._extractionBuilderService.extract(options);
@@ -7088,23 +7163,13 @@ var KadoaClient = class {
    * Connect to realtime WebSocket server
    * Creates a new connection if not already connected
    *
+   * @param options - Optional realtime tuning options (heartbeat/reconnect settings)
    * @returns The Realtime instance
    */
-  connectRealtime() {
+  async connectRealtime(options) {
     if (!this._realtime) {
-      this._realtime = new Realtime({
-        apiKey: this._apiKey,
-        ...this._realtimeConfig?.reconnectDelay != null && {
-          reconnectDelay: this._realtimeConfig.reconnectDelay
-        },
-        ...this._realtimeConfig?.heartbeatInterval != null && {
-          heartbeatInterval: this._realtimeConfig.heartbeatInterval
-        },
-        ...this._realtimeConfig?.source && {
-          source: this._realtimeConfig.source
-        }
-      });
-      this._realtime.connect();
+      this._realtime = new Realtime({ apiKey: this._apiKey, ...options });
+      await this._realtime.connect();
     }
     return this._realtime;
   }
@@ -7143,8 +7208,16 @@ var KadoaClient = class {
   dispose() {
     this.disconnectRealtime();
   }
+  /**
+   * Alias for {@link dispose}. Included for common Node.js client ergonomics.
+   */
+  close() {
+    this.dispose();
+  }
 };
 
+exports.CrawlerConfigService = CrawlerConfigService;
+exports.CrawlerSessionService = CrawlerSessionService;
 exports.DataFetcherService = DataFetcherService;
 exports.ERROR_MESSAGES = ERROR_MESSAGES;
 exports.EntityResolverService = EntityResolverService;
@@ -7159,6 +7232,7 @@ exports.NotificationChannelsService = NotificationChannelsService;
 exports.NotificationSettingsEventTypeEnum = V5NotificationsSettingsGetEventTypeEnum;
 exports.NotificationSettingsService = NotificationSettingsService;
 exports.NotificationSetupService = NotificationSetupService;
+exports.PageStatus = PageStatus;
 exports.Realtime = Realtime;
 exports.SchemaBuilder = SchemaBuilder;
 exports.SchemaFieldDataType = SchemaFieldDataType;
@@ -7169,6 +7243,7 @@ exports.UserService = UserService;
 exports.ValidationCoreService = ValidationCoreService;
 exports.ValidationRulesService = ValidationRulesService;
 exports.WorkflowsCoreService = WorkflowsCoreService;
+exports.createCrawlerDomain = createCrawlerDomain;
 exports.pollUntil = pollUntil;
 exports.validateAdditionalData = validateAdditionalData;
 //# sourceMappingURL=index.js.map