@kadoa/node-sdk 0.11.0 → 0.12.1

package/dist/index.mjs

@@ -2249,15 +2249,13 @@ var V5NotificationsSettingsGetEventTypeEnum = {
 var SchemasApiAxiosParamCreator = function(configuration) {
   return {
     /**
-     * 
-     * @summary Get all schemas
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Retrieve all schemas accessible by the authenticated user
+     * @summary List all schemas
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4SchemasGet: async (xApiKey, authorization, options = {}) => {
-      const localVarPath = `/v4/schemas`;
+    v4SchemasGet: async (options = {}) => {
+      const localVarPath = `/v4/schemas/`;
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
       if (configuration) {
@@ -2267,13 +2265,6 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      if (xApiKey != null) {
-        localVarHeaderParameter["x-api-key"] = String(xApiKey);
-      }
-      if (authorization != null) {
-        localVarHeaderParameter["Authorization"] = String(authorization);
-      }
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2283,17 +2274,14 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * 
-     * @summary Create a new schema
-     * @param {V4SchemasPostRequest} v4SchemasPostRequest 
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Create a new data schema with specified fields and entity type
+     * @summary Create new schema
+     * @param {CreateSchemaBody} [createSchemaBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4SchemasPost: async (v4SchemasPostRequest, xApiKey, authorization, options = {}) => {
-      assertParamExists("v4SchemasPost", "v4SchemasPostRequest", v4SchemasPostRequest);
-      const localVarPath = `/v4/schemas`;
+    v4SchemasPost: async (createSchemaBody, options = {}) => {
+      const localVarPath = `/v4/schemas/`;
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
       if (configuration) {
@@ -2303,33 +2291,24 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
       localVarHeaderParameter["Content-Type"] = "application/json";
-      if (xApiKey != null) {
-        localVarHeaderParameter["x-api-key"] = String(xApiKey);
-      }
-      if (authorization != null) {
-        localVarHeaderParameter["Authorization"] = String(authorization);
-      }
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(v4SchemasPostRequest, localVarRequestOptions, configuration);
+      localVarRequestOptions.data = serializeDataIfNeeded(createSchemaBody, localVarRequestOptions, configuration);
       return {
         url: toPathString(localVarUrlObj),
         options: localVarRequestOptions
       };
     },
     /**
-     * 
-     * @summary Delete a schema
-     * @param {string} schemaId ID of the schema to delete
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Delete a schema and all its revisions
+     * @summary Delete schema
+     * @param {string} schemaId Schema ID
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4SchemasSchemaIdDelete: async (schemaId, xApiKey, authorization, options = {}) => {
+    v4SchemasSchemaIdDelete: async (schemaId, options = {}) => {
       assertParamExists("v4SchemasSchemaIdDelete", "schemaId", schemaId);
       const localVarPath = `/v4/schemas/{schemaId}`.replace(`{${"schemaId"}}`, encodeURIComponent(String(schemaId)));
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -2341,13 +2320,6 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      if (xApiKey != null) {
-        localVarHeaderParameter["x-api-key"] = String(xApiKey);
-      }
-      if (authorization != null) {
-        localVarHeaderParameter["Authorization"] = String(authorization);
-      }
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2357,15 +2329,13 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * 
-     * @summary Get a specific schema by ID
-     * @param {string} schemaId ID of the schema to retrieve
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Retrieve a specific schema by its unique identifier
+     * @summary Get schema by ID
+     * @param {string} schemaId Schema ID
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4SchemasSchemaIdGet: async (schemaId, xApiKey, authorization, options = {}) => {
+    v4SchemasSchemaIdGet: async (schemaId, options = {}) => {
       assertParamExists("v4SchemasSchemaIdGet", "schemaId", schemaId);
       const localVarPath = `/v4/schemas/{schemaId}`.replace(`{${"schemaId"}}`, encodeURIComponent(String(schemaId)));
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -2377,13 +2347,6 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      if (xApiKey != null) {
-        localVarHeaderParameter["x-api-key"] = String(xApiKey);
-      }
-      if (authorization != null) {
-        localVarHeaderParameter["Authorization"] = String(authorization);
-      }
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -2393,18 +2356,15 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * 
-     * @summary Update an existing schema
-     * @param {string} schemaId ID of the schema to update
-     * @param {V4SchemasSchemaIdPutRequest} v4SchemasSchemaIdPutRequest 
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Update schema metadata or create a new revision with updated fields
+     * @summary Update existing schema
+     * @param {string} schemaId Schema ID
+     * @param {UpdateSchemaBody} [updateSchemaBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4SchemasSchemaIdPut: async (schemaId, v4SchemasSchemaIdPutRequest, xApiKey, authorization, options = {}) => {
+    v4SchemasSchemaIdPut: async (schemaId, updateSchemaBody, options = {}) => {
       assertParamExists("v4SchemasSchemaIdPut", "schemaId", schemaId);
-      assertParamExists("v4SchemasSchemaIdPut", "v4SchemasSchemaIdPutRequest", v4SchemasSchemaIdPutRequest);
       const localVarPath = `/v4/schemas/{schemaId}`.replace(`{${"schemaId"}}`, encodeURIComponent(String(schemaId)));
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
@@ -2415,18 +2375,11 @@ var SchemasApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
       localVarHeaderParameter["Content-Type"] = "application/json";
-      if (xApiKey != null) {
-        localVarHeaderParameter["x-api-key"] = String(xApiKey);
-      }
-      if (authorization != null) {
-        localVarHeaderParameter["Authorization"] = String(authorization);
-      }
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(v4SchemasSchemaIdPutRequest, localVarRequestOptions, configuration);
+      localVarRequestOptions.data = serializeDataIfNeeded(updateSchemaBody, localVarRequestOptions, configuration);
       return {
         url: toPathString(localVarUrlObj),
         options: localVarRequestOptions
@@ -2438,76 +2391,66 @@ var SchemasApiFp = function(configuration) {
   const localVarAxiosParamCreator = SchemasApiAxiosParamCreator(configuration);
   return {
     /**
-     * 
-     * @summary Get all schemas
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Retrieve all schemas accessible by the authenticated user
+     * @summary List all schemas
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4SchemasGet(xApiKey, authorization, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasGet(xApiKey, authorization, options);
+    async v4SchemasGet(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasGet(options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["SchemasApi.v4SchemasGet"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * 
-     * @summary Create a new schema
-     * @param {V4SchemasPostRequest} v4SchemasPostRequest 
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Create a new data schema with specified fields and entity type
+     * @summary Create new schema
+     * @param {CreateSchemaBody} [createSchemaBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4SchemasPost(v4SchemasPostRequest, xApiKey, authorization, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasPost(v4SchemasPostRequest, xApiKey, authorization, options);
+    async v4SchemasPost(createSchemaBody, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasPost(createSchemaBody, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["SchemasApi.v4SchemasPost"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * 
-     * @summary Delete a schema
-     * @param {string} schemaId ID of the schema to delete
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Delete a schema and all its revisions
+     * @summary Delete schema
+     * @param {string} schemaId Schema ID
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4SchemasSchemaIdDelete(schemaId, xApiKey, authorization, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdDelete(schemaId, xApiKey, authorization, options);
+    async v4SchemasSchemaIdDelete(schemaId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdDelete(schemaId, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["SchemasApi.v4SchemasSchemaIdDelete"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * 
-     * @summary Get a specific schema by ID
-     * @param {string} schemaId ID of the schema to retrieve
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Retrieve a specific schema by its unique identifier
+     * @summary Get schema by ID
+     * @param {string} schemaId Schema ID
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4SchemasSchemaIdGet(schemaId, xApiKey, authorization, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdGet(schemaId, xApiKey, authorization, options);
+    async v4SchemasSchemaIdGet(schemaId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdGet(schemaId, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["SchemasApi.v4SchemasSchemaIdGet"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * 
-     * @summary Update an existing schema
-     * @param {string} schemaId ID of the schema to update
-     * @param {V4SchemasSchemaIdPutRequest} v4SchemasSchemaIdPutRequest 
-     * @param {string} [xApiKey] API key for authorization
-     * @param {string} [authorization] Bearer token for authorization
+     * Update schema metadata or create a new revision with updated fields
+     * @summary Update existing schema
+     * @param {string} schemaId Schema ID
+     * @param {UpdateSchemaBody} [updateSchemaBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4SchemasSchemaIdPut(schemaId, v4SchemasSchemaIdPutRequest, xApiKey, authorization, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdPut(schemaId, v4SchemasSchemaIdPutRequest, xApiKey, authorization, options);
+    async v4SchemasSchemaIdPut(schemaId, updateSchemaBody, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4SchemasSchemaIdPut(schemaId, updateSchemaBody, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["SchemasApi.v4SchemasSchemaIdPut"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
@@ -2516,54 +2459,53 @@ var SchemasApiFp = function(configuration) {
 };
 var SchemasApi = class extends BaseAPI {
   /**
-   * 
-   * @summary Get all schemas
-   * @param {SchemasApiV4SchemasGetRequest} requestParameters Request parameters.
+   * Retrieve all schemas accessible by the authenticated user
+   * @summary List all schemas
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
-  v4SchemasGet(requestParameters = {}, options) {
-    return SchemasApiFp(this.configuration).v4SchemasGet(requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+  v4SchemasGet(options) {
+    return SchemasApiFp(this.configuration).v4SchemasGet(options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * 
-   * @summary Create a new schema
+   * Create a new data schema with specified fields and entity type
+   * @summary Create new schema
    * @param {SchemasApiV4SchemasPostRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
-  v4SchemasPost(requestParameters, options) {
-    return SchemasApiFp(this.configuration).v4SchemasPost(requestParameters.v4SchemasPostRequest, requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+  v4SchemasPost(requestParameters = {}, options) {
+    return SchemasApiFp(this.configuration).v4SchemasPost(requestParameters.createSchemaBody, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * 
-   * @summary Delete a schema
+   * Delete a schema and all its revisions
+   * @summary Delete schema
    * @param {SchemasApiV4SchemasSchemaIdDeleteRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
   v4SchemasSchemaIdDelete(requestParameters, options) {
-    return SchemasApiFp(this.configuration).v4SchemasSchemaIdDelete(requestParameters.schemaId, requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+    return SchemasApiFp(this.configuration).v4SchemasSchemaIdDelete(requestParameters.schemaId, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * 
-   * @summary Get a specific schema by ID
+   * Retrieve a specific schema by its unique identifier
+   * @summary Get schema by ID
    * @param {SchemasApiV4SchemasSchemaIdGetRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
   v4SchemasSchemaIdGet(requestParameters, options) {
-    return SchemasApiFp(this.configuration).v4SchemasSchemaIdGet(requestParameters.schemaId, requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+    return SchemasApiFp(this.configuration).v4SchemasSchemaIdGet(requestParameters.schemaId, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * 
-   * @summary Update an existing schema
+   * Update schema metadata or create a new revision with updated fields
+   * @summary Update existing schema
    * @param {SchemasApiV4SchemasSchemaIdPutRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
   v4SchemasSchemaIdPut(requestParameters, options) {
-    return SchemasApiFp(this.configuration).v4SchemasSchemaIdPut(requestParameters.schemaId, requestParameters.v4SchemasSchemaIdPutRequest, requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
+    return SchemasApiFp(this.configuration).v4SchemasSchemaIdPut(requestParameters.schemaId, requestParameters.updateSchemaBody, options).then((request) => request(this.axios, this.basePath));
   }
 };
 var WorkflowsApiAxiosParamCreator = function(configuration) {
@@ -2724,15 +2666,14 @@ var WorkflowsApiAxiosParamCreator = function(configuration) {
       };
     },
     /**
-     * 
+     * Create a new workflow with schema, custom fields, or agentic navigation mode
      * @summary Create a new workflow
-     * @param {V4WorkflowsPostRequest} v4WorkflowsPostRequest 
+     * @param {CreateWorkflowBody} [createWorkflowBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    v4WorkflowsPost: async (v4WorkflowsPostRequest, options = {}) => {
-      assertParamExists("v4WorkflowsPost", "v4WorkflowsPostRequest", v4WorkflowsPostRequest);
-      const localVarPath = `/v4/workflows`;
+    v4WorkflowsPost: async (createWorkflowBody, options = {}) => {
+      const localVarPath = `/v4/workflows/`;
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
       if (configuration) {
@@ -2742,12 +2683,11 @@ var WorkflowsApiAxiosParamCreator = function(configuration) {
       const localVarHeaderParameter = {};
       const localVarQueryParameter = {};
       await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
       localVarHeaderParameter["Content-Type"] = "application/json";
       setSearchParams(localVarUrlObj, localVarQueryParameter);
       let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
       localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(v4WorkflowsPostRequest, localVarRequestOptions, configuration);
+      localVarRequestOptions.data = serializeDataIfNeeded(createWorkflowBody, localVarRequestOptions, configuration);
       return {
         url: toPathString(localVarUrlObj),
         options: localVarRequestOptions
@@ -3517,14 +3457,14 @@ var WorkflowsApiFp = function(configuration) {
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
     /**
-     * 
+     * Create a new workflow with schema, custom fields, or agentic navigation mode
      * @summary Create a new workflow
-     * @param {V4WorkflowsPostRequest} v4WorkflowsPostRequest 
+     * @param {CreateWorkflowBody} [createWorkflowBody] Body
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    async v4WorkflowsPost(v4WorkflowsPostRequest, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4WorkflowsPost(v4WorkflowsPostRequest, options);
+    async v4WorkflowsPost(createWorkflowBody, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4WorkflowsPost(createWorkflowBody, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["WorkflowsApi.v4WorkflowsPost"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios5, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
@@ -3861,14 +3801,14 @@ var WorkflowsApi = class extends BaseAPI {
     return WorkflowsApiFp(this.configuration).v4WorkflowsGet(requestParameters.search, requestParameters.skip, requestParameters.limit, requestParameters.state, requestParameters.tags, requestParameters.monitoring, requestParameters.updateInterval, requestParameters.templateId, requestParameters.includeDeleted, requestParameters.format, options).then((request) => request(this.axios, this.basePath));
   }
   /**
-   * 
+   * Create a new workflow with schema, custom fields, or agentic navigation mode
    * @summary Create a new workflow
    * @param {WorkflowsApiV4WorkflowsPostRequest} requestParameters Request parameters.
    * @param {*} [options] Override http request option.
    * @throws {RequiredError}
    */
-  v4WorkflowsPost(requestParameters, options) {
-    return WorkflowsApiFp(this.configuration).v4WorkflowsPost(requestParameters.v4WorkflowsPostRequest, options).then((request) => request(this.axios, this.basePath));
+  v4WorkflowsPost(requestParameters = {}, options) {
+    return WorkflowsApiFp(this.configuration).v4WorkflowsPost(requestParameters.createWorkflowBody, options).then((request) => request(this.axios, this.basePath));
   }
   /**
    * 
@@ -4106,7 +4046,7 @@ var Configuration = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.11.0";
+var SDK_VERSION = "0.12.1";
 var SDK_NAME = "kadoa-node-sdk";
 var SDK_LANGUAGE = "node";
 
@@ -4328,7 +4268,15 @@ var ExtractionModule = class {
    * @param options Extraction configuration options including optional notification settings
    * @returns ExtractionResult containing workflow ID, workflow details, and first page of extracted data
    *
-   * @example
+   * @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'],
@@ -4342,6 +4290,8 @@ var ExtractionModule = class {
    *   }
    * });
    * ```
+   *
+   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
    */
   async run(options) {
     return await this.extractionService.executeExtraction({
@@ -4368,6 +4318,8 @@ var ExtractionModule = class {
    *   }
    * });
    * ```
+   *
+   * @see {@link KadoaClient.extract} For more flexible extraction configuration using the builder API
    */
   async submit(options) {
     return await this.extractionService.executeExtraction({
@@ -4730,13 +4682,7 @@ var ExtractionService = class {
     const result = await this.workflowsCoreService.create({
       ...config,
       entity: resolvedEntity.entity,
-      fields: resolvedEntity.fields.map((field) => ({
-        name: field.name,
-        description: field.description,
-        example: field.example,
-        // todo: there is missmatch in kadoa-api so we need to cast
-        dataType: field.dataType
-      }))
+      fields: resolvedEntity.fields
     });
     workflowId = result.id;
     if (hasNotifications) {
@@ -5205,7 +5151,6 @@ var WorkflowsCoreService = class {
       navigationMode: input.navigationMode,
       entity: input.entity,
       fields: input.fields,
-      //todo: fix this
       bypassPreview: input.bypassPreview ?? true,
       tags: input.tags,
       interval: input.interval,
@@ -5215,7 +5160,7 @@ var WorkflowsCoreService = class {
       schedules: input.schedules
     };
     const response = await this.workflowsApi.v4WorkflowsPost({
-      v4WorkflowsPostRequest: request
+      createWorkflowBody: request
     });
     const workflowId = response.data?.workflowId;
     if (!workflowId) {
@@ -5914,6 +5859,187 @@ var EntityResolverService = class {
     }
   }
 };
+
+// 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" }
+      );
+    }
+    this.schemaName = name;
+    return new SchemaBuilder(this);
+  }
+  /**
+   * 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" }
+      );
+    }
+    this.schemaId = schemaId;
+    return this;
+  }
+  /**
+   * 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;
+      }
+      this.fields.push({
+        name: fieldName,
+        description: `Raw page content in ${f.toUpperCase()} format`,
+        fieldType: "METADATA",
+        metadataKey: metadataKeyMap[f]
+      });
+    }
+    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();
+  }
+  /**
+   * 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)`,
+        {
+          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 }
+      });
+    }
+    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) {
+    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 }
+      });
+    }
+    this.fields.push({
+      name,
+      description,
+      fieldType: "CLASSIFICATION",
+      categories
+    });
+    return this;
+  }
+  /**
+   * Add raw page content alongside structured fields
+   * @param format - Raw content format(s): "html", "markdown", or "url"
+   */
+  raw(format) {
+    return super.raw(format);
+  }
+};
+_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) {
@@ -5945,14 +6071,30 @@ var ExtractionBuilderService = class {
     name,
     description,
     navigationMode,
-    entity
+    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";
+      }
+    }
     this._options = {
       urls,
       name,
       description,
       navigationMode: navigationMode || "single-page",
-      entity: entity || "ai-detection",
+      entity,
       bypassPreview: false
     };
     return this;
@@ -5993,6 +6135,12 @@ var ExtractionBuilderService = class {
       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,
@@ -6000,8 +6148,8 @@ var ExtractionBuilderService = class {
       navigationMode,
       monitoring: this._monitoringOptions,
       schemaId: typeof entity === "object" && "schemId" in entity ? entity.schemId : void 0,
-      entity: resolvedEntity?.entity,
-      fields: resolvedEntity?.fields,
+      entity: resolvedEntity.entity,
+      fields: resolvedEntity.fields,
       autoStart: false,
       interval: this._options.interval,
       schedules: this._options.schedules
@@ -6217,6 +6365,41 @@ var KadoaClient = class {
   get realtime() {
     return this._realtime;
   }
+  /**
+   * Create a prepared extraction using the fluent builder API
+   *
+   * @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);
   }