@io-orkes/conductor-javascript 2.2.0 → 2.2.1

package/dist/index.js

@@ -23555,6 +23555,278 @@ var client = createClient(createConfig({
 }));
 
 // src/common/open-api/sdk.gen.ts
+var EventResource = class {
+  /**
+   * Get all the event handlers
+   */
+  static getEventHandlers(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event",
+      ...options
+    });
+  }
+  /**
+   * Add a new event handler.
+   */
+  static addEventHandler(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Update an existing event handler.
+   */
+  static updateEventHandler(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Handle an incoming event
+   */
+  static handleIncomingEvent(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/handleIncomingEvent",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get event handler by name
+   */
+  static test(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/handler/",
+      ...options
+    });
+  }
+  /**
+   * Get event handler by name
+   */
+  static getEventHandlerByName(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/handler/{name}",
+      ...options
+    });
+  }
+  /**
+   * Get all queue configs
+   */
+  static getQueueNames(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/queue/config",
+      ...options
+    });
+  }
+  /**
+   * Delete queue config by name
+   */
+  static deleteQueueConfig(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/queue/config/{queueType}/{queueName}",
+      ...options
+    });
+  }
+  /**
+   * Get queue config by name
+   */
+  static getQueueConfig(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/queue/config/{queueType}/{queueName}",
+      ...options
+    });
+  }
+  /**
+   * Create or update queue config by name
+   *
+   * @deprecated
+   */
+  static putQueueConfig(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/queue/config/{queueType}/{queueName}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
+   */
+  static testConnectivity(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/queue/connectivity",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get event handlers for a given event
+   */
+  static getEventHandlersForEvent(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/{event}",
+      ...options
+    });
+  }
+  /**
+   * Remove an event handler
+   */
+  static removeEventHandlerStatus(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/{name}",
+      ...options
+    });
+  }
+  /**
+   * Delete a tag for event handler
+   */
+  static deleteTagForEventHandler(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/{name}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get tags by event handler
+   */
+  static getTagsForEventHandler(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/{name}/tags",
+      ...options
+    });
+  }
+  /**
+   * Put a tag to event handler
+   */
+  static putTagForEventHandler(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/{name}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
 var HumanTask = class {
   /**
    * API for backpopulating index data
@@ -23885,53 +24157,51 @@ var HumanTask = class {
     });
   }
 };
-var MetadataResource = class {
+var HumanTaskResource = class {
   /**
-   * Gets all task definition
+   * Get Conductor task by id (for human tasks only)
    */
-  static getTaskDefs(options) {
-    return (options?.client ?? client).get({
+  static getConductorTaskById(options) {
+    return (options.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/metadata/taskdefs",
+      url: "/api/human/tasks/{taskId}/conductorTask",
       ...options
     });
   }
+};
+var UserForm = class {
   /**
-   * Create or update task definition(s)
+   * List all user form templates or get templates by name, or a template by name and version
    */
-  static registerTaskDef(options) {
-    return (options.client ?? client).post({
+  static getAllTemplates(options) {
+    return (options?.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/metadata/taskdefs",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
+      url: "/api/human/template",
+      ...options
     });
   }
   /**
-   * Update an existing task
+   * Save user form template
    */
-  static updateTaskDef(options) {
-    return (options.client ?? client).put({
+  static saveTemplate(options) {
+    return (options.client ?? client).post({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/metadata/taskdefs",
+      url: "/api/human/template",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -23940,10 +24210,129 @@ var MetadataResource = class {
     });
   }
   /**
-   * Remove a task definition
+   * Save user form template
    */
-  static unregisterTaskDef(options) {
-    return (options.client ?? client).delete({
+  static saveTemplates(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/human/template/bulk",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get user form by human task id
+   */
+  static getTemplateByTaskId(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/human/template/{humanTaskId}",
+      ...options
+    });
+  }
+  /**
+   * Delete all versions of user form template by name
+   */
+  static deleteTemplateByName(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/human/template/{name}",
+      ...options
+    });
+  }
+  /**
+   * Get user form template by name and version
+   */
+  static getTemplateByNameAndVersion(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/human/template/{name}/{version}",
+      ...options
+    });
+  }
+};
+var MetadataResource = class {
+  /**
+   * Gets all task definition
+   */
+  static getTaskDefs(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/metadata/taskdefs",
+      ...options
+    });
+  }
+  /**
+   * Create or update task definition(s)
+   */
+  static registerTaskDef(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/metadata/taskdefs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Update an existing task
+   */
+  static updateTaskDef(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/metadata/taskdefs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Remove a task definition
+   */
+  static unregisterTaskDef(options) {
+    return (options.client ?? client).delete({
       security: [
         {
           name: "X-Authorization",
@@ -24087,11 +24476,8 @@ var MetadataResource = class {
     });
   }
 };
-var SchedulerResource = class {
-  /**
-   * Pause all scheduling in a single conductor server instance (for debugging only)
-   */
-  static pauseAllSchedules(options) {
+var ServiceRegistryResource = class {
+  static getRegisteredServices(options) {
     return (options?.client ?? client).get({
       security: [
         {
@@ -24099,153 +24485,128 @@ var SchedulerResource = class {
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/admin/pause",
+      url: "/api/registry/service",
       ...options
     });
   }
-  /**
-   * Requeue all execution records
-   */
-  static requeueAllExecutionRecords(options) {
-    return (options?.client ?? client).get({
+  static addOrUpdateService(options) {
+    return (options.client ?? client).post({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/admin/requeue",
-      ...options
+      url: "/api/registry/service",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
     });
   }
-  /**
-   * Resume all scheduling
-   */
-  static resumeAllSchedules(options) {
-    return (options?.client ?? client).get({
+  static getAllProtos(options) {
+    return (options.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/admin/resume",
+      url: "/api/registry/service/protos/{registryName}",
       ...options
     });
   }
-  /**
-   * Get list of the next x (default 3, max 5) execution times for a scheduler
-   */
-  static getNextFewSchedules(options) {
-    return (options.client ?? client).get({
+  static deleteProto(options) {
+    return (options.client ?? client).delete({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/nextFewSchedules",
+      url: "/api/registry/service/protos/{registryName}/{filename}",
       ...options
     });
   }
-  /**
-   * Get all existing workflow schedules and optionally filter by workflow name
-   */
-  static getAllSchedules(options) {
-    return (options?.client ?? client).get({
+  static getProtoData(options) {
+    return (options.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules",
+      url: "/api/registry/service/protos/{registryName}/{filename}",
       ...options
     });
   }
-  /**
-   * Create or update a schedule for a specified workflow with a corresponding start workflow request
-   */
-  static saveSchedule(options) {
+  static setProtoData(options) {
     return (options.client ?? client).post({
+      bodySerializer: null,
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules",
+      url: "/api/registry/service/protos/{registryName}/{filename}",
       ...options,
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "application/octet-stream",
         ...options.headers
       }
     });
   }
-  /**
-   * Get schedules by tag
-   */
-  static getSchedulesByTag(options) {
-    return (options.client ?? client).get({
+  static removeService(options) {
+    return (options.client ?? client).delete({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/tags",
+      url: "/api/registry/service/{name}",
       ...options
     });
   }
-  /**
-   * Deletes an existing workflow schedule by name
-   */
-  static deleteSchedule(options) {
-    return (options.client ?? client).delete({
+  static getService(options) {
+    return (options.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}",
+      url: "/api/registry/service/{name}",
       ...options
     });
   }
-  /**
-   * Get an existing workflow schedule by name
-   */
-  static getSchedule(options) {
-    return (options.client ?? client).get({
+  static closeCircuitBreaker(options) {
+    return (options.client ?? client).post({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}",
+      url: "/api/registry/service/{name}/circuit-breaker/close",
       ...options
     });
   }
-  /**
-   * Pauses an existing schedule by name
-   */
-  static pauseSchedule(options) {
-    return (options.client ?? client).get({
+  static openCircuitBreaker(options) {
+    return (options.client ?? client).post({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}/pause",
+      url: "/api/registry/service/{name}/circuit-breaker/open",
       ...options
     });
   }
-  /**
-   * Resume a paused schedule by name
-   */
-  static resumeSchedule(options) {
+  static getCircuitBreakerStatus(options) {
     return (options.client ?? client).get({
       security: [
         {
@@ -24253,56 +24614,43 @@ var SchedulerResource = class {
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}/resume",
+      url: "/api/registry/service/{name}/circuit-breaker/status",
       ...options
     });
   }
-  /**
-   * Delete a tag for schedule
-   */
-  static deleteTagForSchedule(options) {
-    return (options.client ?? client).delete({
+  static discover(options) {
+    return (options.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}/tags",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
+      url: "/api/registry/service/{name}/discover",
+      ...options
     });
   }
-  /**
-   * Get tags by schedule
-   */
-  static getTagsForSchedule(options) {
-    return (options.client ?? client).get({
+  static removeMethod(options) {
+    return (options.client ?? client).delete({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}/tags",
+      url: "/api/registry/service/{registryName}/methods",
       ...options
     });
   }
-  /**
-   * Put a tag to schedule
-   */
-  static putTagForSchedule(options) {
-    return (options.client ?? client).put({
+  static addOrUpdateMethod(options) {
+    return (options.client ?? client).post({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/schedules/{name}/tags",
+      url: "/api/registry/service/{registryName}/methods",
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -24310,12 +24658,12 @@ var SchedulerResource = class {
       }
     });
   }
+};
+var SchedulerResource = class {
   /**
-   * Search for workflow executions based on payload and other parameters
-   *
-   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+   * Pause all scheduling in a single conductor server instance (for debugging only)
    */
-  static searchV2(options) {
+  static pauseAllSchedules(options) {
     return (options?.client ?? client).get({
       security: [
         {
@@ -24323,35 +24671,259 @@ var SchedulerResource = class {
           type: "apiKey"
         }
       ],
-      url: "/api/scheduler/search/executions",
+      url: "/api/scheduler/admin/pause",
       ...options
     });
   }
-};
-var TaskResource = class {
   /**
-   * Update a task
+   * Requeue all execution records
    */
-  static updateTask(options) {
-    return (options.client ?? client).post({
+  static requeueAllExecutionRecords(options) {
+    return (options?.client ?? client).get({
       security: [
         {
           name: "X-Authorization",
           type: "apiKey"
         }
       ],
-      url: "/api/tasks",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
+      url: "/api/scheduler/admin/requeue",
+      ...options
     });
   }
   /**
-   * Batch poll for a task of a certain type
+   * Resume all scheduling
    */
-  static batchPoll(options) {
+  static resumeAllSchedules(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/admin/resume",
+      ...options
+    });
+  }
+  /**
+   * Get list of the next x (default 3, max 5) execution times for a scheduler
+   */
+  static getNextFewSchedules(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/nextFewSchedules",
+      ...options
+    });
+  }
+  /**
+   * Get all existing workflow schedules and optionally filter by workflow name
+   */
+  static getAllSchedules(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules",
+      ...options
+    });
+  }
+  /**
+   * Create or update a schedule for a specified workflow with a corresponding start workflow request
+   */
+  static saveSchedule(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get schedules by tag
+   */
+  static getSchedulesByTag(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/tags",
+      ...options
+    });
+  }
+  /**
+   * Deletes an existing workflow schedule by name
+   */
+  static deleteSchedule(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}",
+      ...options
+    });
+  }
+  /**
+   * Get an existing workflow schedule by name
+   */
+  static getSchedule(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}",
+      ...options
+    });
+  }
+  /**
+   * Pauses an existing schedule by name
+   */
+  static pauseSchedule(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}/pause",
+      ...options
+    });
+  }
+  /**
+   * Resume a paused schedule by name
+   */
+  static resumeSchedule(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}/resume",
+      ...options
+    });
+  }
+  /**
+   * Delete a tag for schedule
+   */
+  static deleteTagForSchedule(options) {
+    return (options.client ?? client).delete({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get tags by schedule
+   */
+  static getTagsForSchedule(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}/tags",
+      ...options
+    });
+  }
+  /**
+   * Put a tag to schedule
+   */
+  static putTagForSchedule(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/schedules/{name}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Search for workflow executions based on payload and other parameters
+   *
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+   */
+  static searchV2(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/scheduler/search/executions",
+      ...options
+    });
+  }
+};
+var TaskResource = class {
+  /**
+   * Update a task
+   */
+  static updateTask(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/tasks",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Batch poll for a task of a certain type
+   */
+  static batchPoll(options) {
     return (options.client ?? client).get({
       security: [
         {
@@ -25179,31 +25751,161 @@ var WorkflowResource = class {
     });
   }
 };
-
-// src/task/constants.ts
-var DEFAULT_POLL_INTERVAL = 100;
-var DEFAULT_CONCURRENCY = 1;
-var DEFAULT_WARN_AT_O = 100;
-var DEFAULT_BATCH_POLLING_TIMEOUT = 100;
-
-// src/task/Poller.ts
-var Poller = class {
-  timeoutHandler;
-  pollFunction;
-  performWorkFunction;
-  polling = false;
-  _tasksInProcess = 0;
-  _counterAtO = 0;
-  _pollerId = "";
-  options = {
-    pollInterval: DEFAULT_POLL_INTERVAL,
-    concurrency: DEFAULT_CONCURRENCY,
-    warnAtO: DEFAULT_WARN_AT_O
-  };
-  logger = noopLogger;
-  constructor(pollerId, pollFunction, performWorkFunction, pollerOptions, logger) {
-    this._pollerId = pollerId;
-    this.pollFunction = pollFunction;
+var WorkflowBulkResource = class {
+  /**
+   * Permanently remove workflows from the system
+   */
+  static delete(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/delete",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Pause the list of workflows
+   */
+  static pauseWorkflow1(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/pause",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Restart the list of completed workflow
+   */
+  static restart1(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/restart",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Resume the list of workflows
+   */
+  static resumeWorkflow1(options) {
+    return (options.client ?? client).put({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/resume",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Retry the last failed task for each workflow from the list
+   */
+  static retry1(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/retry",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Terminate workflows execution
+   */
+  static terminate(options) {
+    return (options.client ?? client).post({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/workflow/bulk/terminate",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var HealthCheckResource = class {
+  static doCheck(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/health",
+      ...options
+    });
+  }
+};
+
+// src/task/constants.ts
+var DEFAULT_POLL_INTERVAL = 100;
+var DEFAULT_CONCURRENCY = 1;
+var DEFAULT_WARN_AT_O = 100;
+var DEFAULT_BATCH_POLLING_TIMEOUT = 100;
+
+// src/task/Poller.ts
+var Poller = class {
+  timeoutHandler;
+  pollFunction;
+  performWorkFunction;
+  polling = false;
+  _tasksInProcess = 0;
+  _counterAtO = 0;
+  _pollerId = "";
+  options = {
+    pollInterval: DEFAULT_POLL_INTERVAL,
+    concurrency: DEFAULT_CONCURRENCY,
+    warnAtO: DEFAULT_WARN_AT_O
+  };
+  logger = noopLogger;
+  constructor(pollerId, pollFunction, performWorkFunction, pollerOptions, logger) {
+    this._pollerId = pollerId;
+    this.pollFunction = pollFunction;
     this.performWorkFunction = performWorkFunction;
     this.options = { ...this.options, ...pollerOptions };
     this.logger = logger || noopLogger;
@@ -27614,6 +28316,1477 @@ var wrapFetchWithRetry = (fetchFn) => {
   };
 };
 
+// src/orkes/helpers/addResourcesBackwardCompatibility.ts
+var warn = () => {
+  console.warn(
+    "[Conductor SDK Deprecation Warning] Accessing resources directly on the client is deprecated and will be removed after April 2026"
+  );
+};
+var addResourcesBackwardCompatibility = (client2) => {
+  const eventResource = {
+    /**
+     * @deprecated
+     */
+    getQueueConfig: async (queueType, queueName) => {
+      warn();
+      const { data } = await EventResource.getQueueConfig({
+        client: client2,
+        path: { queueType, queueName },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    putQueueConfig: async (queueType, queueName, body) => {
+      warn();
+      await EventResource.putQueueConfig({
+        client: client2,
+        path: { queueType, queueName },
+        body,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    deleteQueueConfig: async (queueType, queueName) => {
+      warn();
+      await EventResource.deleteQueueConfig({
+        client: client2,
+        path: { queueType, queueName },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getEventHandlers: async () => {
+      warn();
+      const { data } = await EventResource.getEventHandlers({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateEventHandler: async (body) => {
+      warn();
+      await EventResource.updateEventHandler({
+        client: client2,
+        body,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    addEventHandler: async (body) => {
+      warn();
+      await EventResource.addEventHandler({
+        client: client2,
+        body,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getQueueNames: async () => {
+      warn();
+      const { data } = await EventResource.getQueueNames({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    removeEventHandlerStatus: async (name) => {
+      warn();
+      await EventResource.removeEventHandlerStatus({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getEventHandlersForEvent: async (event, activeOnly = true) => {
+      warn();
+      const { data } = await EventResource.getEventHandlersForEvent({
+        client: client2,
+        path: { event },
+        query: { activeOnly },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    deleteTagForEventHandler: async (name, body) => {
+      warn();
+      await EventResource.deleteTagForEventHandler({
+        client: client2,
+        path: { name },
+        body,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getTagsForEventHandler: async (name) => {
+      warn();
+      const { data } = await EventResource.getTagsForEventHandler({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    putTagForEventHandler: async (name, body) => {
+      warn();
+      await EventResource.putTagForEventHandler({
+        client: client2,
+        path: { name },
+        body,
+        throwOnError: true
+      });
+    }
+  };
+  const healthCheckResource = {
+    doCheck: async () => {
+      warn();
+      const { data } = await HealthCheckResource.doCheck({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const metadataResource = {
+    getTaskDef: async (tasktype, metadata = false) => {
+      warn();
+      const { data } = await MetadataResource.getTaskDef({
+        client: client2,
+        path: { tasktype },
+        query: { metadata },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    unregisterTaskDef: async (tasktype) => {
+      warn();
+      await MetadataResource.unregisterTaskDef({
+        client: client2,
+        path: { tasktype },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getAllWorkflows: async (access = "READ", metadata = false, tagKey, tagValue) => {
+      warn();
+      const { data } = await MetadataResource.getWorkflowDefs({
+        client: client2,
+        query: { access, metadata, tagKey, tagValue },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    update: async (requestBody, overwrite = true) => {
+      warn();
+      await MetadataResource.update({
+        client: client2,
+        body: requestBody,
+        query: { overwrite },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    create: async (requestBody, overwrite = false) => {
+      warn();
+      await MetadataResource.create({
+        client: client2,
+        body: requestBody,
+        query: { overwrite },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getTaskDefs: async (access = "READ", metadata = false, tagKey, tagValue) => {
+      warn();
+      const { data } = await MetadataResource.getTaskDefs({
+        client: client2,
+        query: { access, metadata, tagKey, tagValue },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateTaskDef: async (requestBody) => {
+      warn();
+      await MetadataResource.updateTaskDef({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    registerTaskDef: async (requestBody) => {
+      warn();
+      await MetadataResource.registerTaskDef({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    unregisterWorkflowDef: async (name, version) => {
+      warn();
+      await MetadataResource.unregisterWorkflowDef({
+        client: client2,
+        path: { name, version },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    get: async (name, version, metadata = false) => {
+      warn();
+      const { data } = await MetadataResource.get1({
+        client: client2,
+        path: { name },
+        query: { version, metadata },
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const schedulerResource = {
+    getSchedule: async (name) => {
+      warn();
+      const { data } = await SchedulerResource.getSchedule({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    deleteSchedule: async (name) => {
+      warn();
+      await SchedulerResource.deleteSchedule({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getNextFewSchedules: async (cronExpression, scheduleStartTime, scheduleEndTime, limit = 3) => {
+      warn();
+      const { data } = await SchedulerResource.getNextFewSchedules({
+        client: client2,
+        query: { cronExpression, scheduleStartTime, scheduleEndTime, limit },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    pauseSchedule: async (name) => {
+      warn();
+      await SchedulerResource.pauseSchedule({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    pauseAllSchedules: async () => {
+      warn();
+      const { data } = await SchedulerResource.pauseAllSchedules({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    resumeSchedule: async (name) => {
+      warn();
+      await SchedulerResource.resumeSchedule({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    requeueAllExecutionRecords: async () => {
+      warn();
+      const { data } = await SchedulerResource.requeueAllExecutionRecords({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    resumeAllSchedules: async () => {
+      warn();
+      const { data } = await SchedulerResource.resumeAllSchedules({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getAllSchedules: async (workflowName) => {
+      warn();
+      const { data } = await SchedulerResource.getAllSchedules({
+        client: client2,
+        query: { workflowName },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    saveSchedule: async (requestBody) => {
+      warn();
+      await SchedulerResource.saveSchedule({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    searchV21: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await SchedulerResource.searchV2({
+        client: client2,
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    testTimeout: async () => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/scheduler/test/timeout",
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const tokenResource = {
+    generateToken: async (requestBody) => {
+      warn();
+      const { data } = await TokenResource.generateToken({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    getUserInfo: async (claims = false) => {
+      warn();
+      const { data } = await TokenResource.getUserInfo({
+        client: client2,
+        query: { claims },
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const workflowBulkResource = {
+    retry: async (requestBody) => {
+      warn();
+      const { data } = await WorkflowBulkResource.retry1({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    restart: async (requestBody, useLatestDefinitions = false) => {
+      warn();
+      const { data } = await WorkflowBulkResource.restart1({
+        client: client2,
+        body: requestBody,
+        query: { useLatestDefinitions },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    terminate: async (requestBody, reason) => {
+      warn();
+      const { data } = await WorkflowBulkResource.terminate({
+        client: client2,
+        body: requestBody,
+        query: { reason },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    resumeWorkflow: async (requestBody) => {
+      warn();
+      const { data } = await WorkflowBulkResource.resumeWorkflow1({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    pauseWorkflow1: async (requestBody) => {
+      warn();
+      const { data } = await WorkflowBulkResource.pauseWorkflow1({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const workflowResource = {
+    getRunningWorkflow: async (name, version = 1, startTime, endTime) => {
+      warn();
+      const { data } = await WorkflowResource.getRunningWorkflow({
+        client: client2,
+        path: { name },
+        query: { version, startTime, endTime },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    executeWorkflow: async (body, name, version, requestId, waitUntilTaskRef, waitForSeconds, consistency, returnStrategy) => {
+      warn();
+      const { data } = await WorkflowResource.executeWorkflow({
+        client: client2,
+        path: { name, version },
+        query: {
+          requestId,
+          waitUntilTaskRef,
+          waitForSeconds,
+          consistency,
+          returnStrategy
+        },
+        body,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    startWorkflow: async (requestBody) => {
+      warn();
+      const { data } = await WorkflowResource.startWorkflow({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    decide: async (workflowId) => {
+      warn();
+      await WorkflowResource.decide({
+        client: client2,
+        path: { workflowId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    rerun: async (workflowId, requestBody) => {
+      warn();
+      const { data } = await WorkflowResource.rerun({
+        client: client2,
+        path: { workflowId },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    searchV21: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/workflow/search-v2",
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    pauseWorkflow: async (workflowId) => {
+      warn();
+      await WorkflowResource.pauseWorkflow({
+        client: client2,
+        path: { workflowId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    skipTaskFromWorkflow: async (workflowId, taskReferenceName, requestBody) => {
+      warn();
+      await WorkflowResource.skipTaskFromWorkflow({
+        client: client2,
+        path: { workflowId, taskReferenceName },
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getWorkflows: async (name, requestBody, includeClosed = false, includeTasks = false) => {
+      warn();
+      const { data } = await WorkflowResource.getWorkflows({
+        client: client2,
+        path: { name },
+        query: { includeClosed, includeTasks },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getWorkflowStatusSummary: async (workflowId, includeOutput = false, includeVariables = false) => {
+      warn();
+      const { data } = await WorkflowResource.getWorkflowStatusSummary({
+        client: client2,
+        path: { workflowId },
+        query: { includeOutput, includeVariables },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getWorkflows1: async (name, correlationId, includeClosed = false, includeTasks = false) => {
+      warn();
+      const { data } = await WorkflowResource.getWorkflows2({
+        client: client2,
+        path: { name, correlationId },
+        query: { includeClosed, includeTasks },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    retry1: async (workflowId, resumeSubworkflowTasks = false) => {
+      warn();
+      await WorkflowResource.retry({
+        client: client2,
+        path: { workflowId },
+        query: { resumeSubworkflowTasks },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getExecutionStatus: async (workflowId, includeTasks = true) => {
+      warn();
+      const { data } = await WorkflowResource.getExecutionStatus({
+        client: client2,
+        path: { workflowId },
+        query: { includeTasks },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    terminate1: async (workflowId, reason) => {
+      warn();
+      await WorkflowResource.terminate1({
+        client: client2,
+        path: { workflowId },
+        query: { reason },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    resumeWorkflow: async (workflowId) => {
+      warn();
+      await WorkflowResource.resumeWorkflow({
+        client: client2,
+        path: { workflowId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    delete: async (workflowId, archiveWorkflow = true) => {
+      warn();
+      await WorkflowResource.delete1({
+        client: client2,
+        path: { workflowId },
+        query: { archiveWorkflow },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    searchWorkflowsByTasks: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/workflow/search-by-tasks",
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getExternalStorageLocation: async (path, operation, payloadType) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/workflow/externalstoragelocation",
+        query: { path, operation, payloadType },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    startWorkflow1: async (name, requestBody, version, correlationId, priority) => {
+      warn();
+      const { data } = await WorkflowResource.startWorkflow1({
+        client: client2,
+        path: { name },
+        query: { version, correlationId, priority },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    restart1: async (workflowId, useLatestDefinitions = false) => {
+      warn();
+      await WorkflowResource.restart({
+        client: client2,
+        path: { workflowId },
+        query: { useLatestDefinitions },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    search1: async (queryId, start, size = 100, sort, freeText = "*", query, skipCache = false) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/workflow/search",
+        query: { queryId, start, size, sort, freeText, query, skipCache },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    searchWorkflowsByTasksV2: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/workflow/search-by-tasks-v2",
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    resetWorkflow: async (workflowId) => {
+      warn();
+      await WorkflowResource.resetWorkflow({
+        client: client2,
+        path: { workflowId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    testWorkflow: async (requestBody) => {
+      warn();
+      const { data } = await WorkflowResource.testWorkflow({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const serviceRegistryResource = {
+    getRegisteredServices: async () => {
+      warn();
+      const { data } = await ServiceRegistryResource.getRegisteredServices({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    removeService: async (name) => {
+      warn();
+      await ServiceRegistryResource.removeService({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getService: async (name) => {
+      warn();
+      const { data } = await ServiceRegistryResource.getService({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    openCircuitBreaker: async (name) => {
+      warn();
+      const { data } = await ServiceRegistryResource.openCircuitBreaker({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    closeCircuitBreaker: async (name) => {
+      warn();
+      const { data } = await ServiceRegistryResource.closeCircuitBreaker({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getCircuitBreakerStatus: async (name) => {
+      warn();
+      const { data } = await ServiceRegistryResource.getCircuitBreakerStatus({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    addOrUpdateService: async (serviceRegistry) => {
+      warn();
+      await ServiceRegistryResource.addOrUpdateService({
+        client: client2,
+        body: serviceRegistry,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    addOrUpdateServiceMethod: async (registryName, method) => {
+      warn();
+      await ServiceRegistryResource.addOrUpdateMethod({
+        client: client2,
+        path: { registryName },
+        body: method,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    removeMethod: async (registryName, serviceName, method, methodType) => {
+      warn();
+      await ServiceRegistryResource.removeMethod({
+        client: client2,
+        path: { registryName },
+        query: { serviceName, method, methodType },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getProtoData: async (registryName, filename) => {
+      warn();
+      const { data } = await ServiceRegistryResource.getProtoData({
+        client: client2,
+        path: { registryName, filename },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    setProtoData: async (registryName, filename, data) => {
+      warn();
+      await ServiceRegistryResource.setProtoData({
+        client: client2,
+        path: { registryName, filename },
+        body: data,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    deleteProto: async (registryName, filename) => {
+      warn();
+      await ServiceRegistryResource.deleteProto({
+        client: client2,
+        path: { registryName, filename },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getAllProtos: async (registryName) => {
+      warn();
+      const { data } = await ServiceRegistryResource.getAllProtos({
+        client: client2,
+        path: { registryName },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    discover: async (name, create = false) => {
+      warn();
+      const { data } = await ServiceRegistryResource.discover({
+        client: client2,
+        path: { name },
+        query: { create },
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const humanTaskResource = {
+    getConductorTaskById: async (taskId) => {
+      warn();
+      const { data } = await HumanTaskResource.getConductorTaskById({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const humanTask = {
+    deleteTaskFromHumanTaskRecords: async (requestBody) => {
+      warn();
+      await HumanTask.deleteTaskFromHumanTaskRecords({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    deleteTaskFromHumanTaskRecords1: async (taskId) => {
+      warn();
+      await HumanTask.deleteTaskFromHumanTaskRecords1({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    search: async (requestBody) => {
+      warn();
+      const { data } = await HumanTask.search({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateTaskOutputByRef: async (workflowId, taskRefName, requestBody, complete = false, iteration) => {
+      warn();
+      const { data } = await HumanTask.updateTaskOutputByRef({
+        client: client2,
+        query: {
+          workflowId,
+          taskRefName,
+          complete,
+          iteration
+        },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getTask1: async (taskId) => {
+      warn();
+      const { data } = await HumanTask.getTask1({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    claimTask: async (taskId, overrideAssignment = false, withTemplate = false) => {
+      warn();
+      const { data } = await HumanTask.claimTask({
+        client: client2,
+        path: { taskId },
+        query: { overrideAssignment, withTemplate },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    assignAndClaim: async (taskId, userId, overrideAssignment = false, withTemplate = false) => {
+      warn();
+      const { data } = await HumanTask.assignAndClaim({
+        client: client2,
+        path: { taskId, userId },
+        query: { overrideAssignment, withTemplate },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    reassignTask: async (taskId, requestBody) => {
+      warn();
+      await HumanTask.reassignTask({
+        client: client2,
+        path: { taskId },
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    releaseTask: async (taskId) => {
+      warn();
+      await HumanTask.releaseTask({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    skipTask: async (taskId, reason) => {
+      warn();
+      await HumanTask.skipTask({
+        client: client2,
+        path: { taskId },
+        query: { reason },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    updateTaskOutput: async (taskId, requestBody, complete = false) => {
+      warn();
+      await HumanTask.updateTaskOutput({
+        client: client2,
+        path: { taskId },
+        query: { complete },
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getAllTemplates: async (name, version) => {
+      warn();
+      const { data } = await UserForm.getAllTemplates({
+        client: client2,
+        query: { name, version },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    saveTemplate: async (requestBody, newVersion = false) => {
+      warn();
+      const { data } = await UserForm.saveTemplate({
+        client: client2,
+        query: { newVersion },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    saveTemplates: async (requestBody, newVersion = false) => {
+      warn();
+      const { data } = await UserForm.saveTemplates({
+        client: client2,
+        query: { newVersion },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    deleteTemplateByName: async (name) => {
+      warn();
+      await UserForm.deleteTemplateByName({
+        client: client2,
+        path: { name },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    deleteTemplatesByNameAndVersion: async (name, version) => {
+      warn();
+      await HumanTask.deleteTemplatesByNameAndVersion({
+        client: client2,
+        path: { name, version },
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getTemplateByNameAndVersion: async (name, version) => {
+      warn();
+      const { data } = await UserForm.getTemplateByNameAndVersion({
+        client: client2,
+        path: { name, version },
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  const taskResource = {
+    poll: async (tasktype, workerid, domain) => {
+      warn();
+      const { data } = await TaskResource.poll({
+        client: client2,
+        path: { tasktype },
+        query: { workerid, domain },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    allVerbose: async () => {
+      warn();
+      const { data } = await TaskResource.allVerbose({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateTask: async (workflowId, taskRefName, status, requestBody) => {
+      warn();
+      const { data } = await TaskResource.updateTask1({
+        client: client2,
+        path: { workflowId, taskRefName, status },
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getTask: async (taskId) => {
+      warn();
+      const { data } = await TaskResource.getTask({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    all: async () => {
+      warn();
+      const { data } = await TaskResource.all({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    requeuePendingTask: async (taskType) => {
+      warn();
+      const { data } = await TaskResource.requeuePendingTask({
+        client: client2,
+        path: { taskType },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    search: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await TaskResource.search2({
+        client: client2,
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    searchV22: async (start, size = 100, sort, freeText = "*", query) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/tasks/search-v2",
+        query: { start, size, sort, freeText, query },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getPollData: async (taskType) => {
+      warn();
+      const { data } = await TaskResource.getPollData({
+        client: client2,
+        query: { taskType },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getTaskLogs: async (taskId) => {
+      warn();
+      const { data } = await TaskResource.getTaskLogs({
+        client: client2,
+        path: { taskId },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    log: async (taskId, requestBody) => {
+      warn();
+      await TaskResource.log({
+        client: client2,
+        path: { taskId },
+        body: requestBody,
+        throwOnError: true
+      });
+    },
+    /**
+     * @deprecated
+     */
+    getAllPollData: async () => {
+      warn();
+      const { data } = await TaskResource.getAllPollData({
+        client: client2,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    batchPoll: async (tasktype, workerid, domain, count = 1, timeout = 100) => {
+      warn();
+      const { data } = await TaskResource.batchPoll({
+        client: client2,
+        path: { tasktype },
+        query: { workerid, domain, count, timeout },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateTask1: async (requestBody) => {
+      warn();
+      const { data } = await TaskResource.updateTask({
+        client: client2,
+        body: requestBody,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    size1: async (taskType) => {
+      warn();
+      const { data } = await TaskResource.size({
+        client: client2,
+        query: { taskType },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    getExternalStorageLocation1: async (path, operation, payloadType) => {
+      warn();
+      const { data } = await client2.get({
+        security: [
+          {
+            name: "X-Authorization",
+            type: "apiKey"
+          }
+        ],
+        url: "/api/tasks/externalstoragelocation",
+        query: { path, operation, payloadType },
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    updateTaskSync: async (workflowId, taskRefName, status, output, workerId2) => {
+      warn();
+      const { data } = await TaskResource.updateTaskSync({
+        client: client2,
+        path: { workflowId, taskRefName, status },
+        query: { workerid: workerId2 },
+        body: output,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    signal: async (workflowId, status, output, returnStrategy = "TARGET_WORKFLOW") => {
+      warn();
+      const { data } = await TaskResource.signalWorkflowTaskSync({
+        client: client2,
+        path: { workflowId, status },
+        query: { returnStrategy },
+        body: output,
+        throwOnError: true
+      });
+      return data;
+    },
+    /**
+     * @deprecated
+     */
+    signalAsync: async (workflowId, status, output) => {
+      warn();
+      const { data } = await TaskResource.signalWorkflowTaskASync({
+        client: client2,
+        path: { workflowId, status },
+        body: output,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return {
+    ...client2,
+    eventResource,
+    healthCheckResource,
+    metadataResource,
+    schedulerResource,
+    tokenResource,
+    workflowBulkResource,
+    workflowResource,
+    serviceRegistryResource,
+    humanTaskResource,
+    humanTask,
+    taskResource
+  };
+};
+
 // src/orkes/OrkesConductorClient.ts
 var orkesConductorClient = async (config, customFetch) => {
   const {
@@ -27634,7 +29807,7 @@ var orkesConductorClient = async (config, customFetch) => {
   if (keyId && keySecret) {
     await handleAuth(openApiClient, keyId, keySecret, refreshTokenInterval);
   }
-  return openApiClient;
+  return addResourcesBackwardCompatibility(openApiClient);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {