@hatchet-dev/typescript-sdk 1.0.0-alpha1 → 1.0.0

package/v1/client/client.d.ts

@@ -2,19 +2,30 @@ import { ClientConfig, InternalHatchetClient, HatchetClientOptions } from '../..
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
-import { JsonObject } from '../../step';
-import { CreateWorkflowOpts, RunOpts, WorkflowDeclaration } from '../workflow';
+import { JsonObject, DurableContext } from '../../step';
+import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration } from '../declaration';
 import { IHatchetClient } from './client.interface';
 import { CreateWorkerOpts, Worker } from './worker';
+import { MetricsClient } from './features/metrics';
+import { WorkersClient } from './features/workers';
+import { WorkflowsClient } from './features/workflows';
+import { RunsClient } from './features/runs';
+import { CreateStandaloneDurableTaskOpts } from '../task';
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
  */
 export declare class HatchetClient implements IHatchetClient {
     /** The underlying v0 client instance */
-    v0: InternalHatchetClient;
+    _v0: InternalHatchetClient;
+    /**
+     * @deprecated v0 client will be removed in a future release, please upgrade to v1
+     */
+    get v0(): InternalHatchetClient;
     /** The tenant ID for the Hatchet client */
     get tenantId(): string;
+    _isV1: boolean | undefined;
+    get isV1(): boolean;
     /**
      * Creates a new Hatchet client instance.
      * @param config - Optional configuration for the client
@@ -39,6 +50,42 @@ export declare class HatchetClient implements IHatchetClient {
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
     workflow<T extends JsonObject = any, K extends JsonObject = any>(options: CreateWorkflowOpts): WorkflowDeclaration<T, K>;
+    /**
+     * Creates a new task workflow.
+     * Types can be explicitly specified as generics or inferred from the function signature.
+     * @template T The input type for the task
+     * @template K The output type of the task
+     * @param options Task configuration options
+     * @returns A TaskWorkflowDeclaration instance
+     */
+    task<T extends JsonObject, K extends JsonObject>(options: CreateTaskWorkflowOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    /**
+     * Creates a new task workflow with types inferred from the function parameter.
+     * @template Fn The type of the task function with input and output extending JsonObject
+     * @param options Task configuration options with function that defines types
+     * @returns A TaskWorkflowDeclaration instance with inferred types
+     */
+    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+        fn: Fn;
+    } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    /**
+     * Creates a new durable task workflow.
+     * Types can be explicitly specified as generics or inferred from the function signature.
+     * @template T The input type for the durable task
+     * @template K The output type of the durable task
+     * @param options Durable task configuration options
+     * @returns A TaskWorkflowDeclaration instance for a durable task
+     */
+    durableTask<T extends JsonObject, K extends JsonObject>(options: CreateStandaloneDurableTaskOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    /**
+     * Creates a new durable task workflow with types inferred from the function parameter.
+     * @template Fn The type of the durable task function with input and output extending JsonObject
+     * @param options Durable task configuration options with function that defines types
+     * @returns A TaskWorkflowDeclaration instance with inferred types
+     */
+    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+        fn: Fn;
+    } & Omit<CreateStandaloneDurableTaskOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
      * Triggers a workflow run without waiting for completion.
      * @template T - The input type for the workflow
@@ -48,8 +95,9 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    enqueue<T extends JsonObject = any, K extends JsonObject = any>(workflow: WorkflowDeclaration<T, K> | string | V0Workflow, input: T, options: RunOpts): WorkflowRunRef<K>;
+    runNoWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options: RunOpts): WorkflowRunRef<K>;
     /**
+     * @alias run
      * Triggers a workflow run and waits for the result.
      * @template T - The input type for the workflow
      * @template K - The return type of the workflow
@@ -58,13 +106,82 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    run<T extends JsonObject = any, K extends JsonObject = any>(workflow: WorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    runAndWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    /**
+     * Triggers a workflow run and waits for the result.
+     * @template T - The input type for the workflow
+     * @template K - The return type of the workflow
+     * @param workflow - The workflow to run, either as a Workflow instance or workflow name
+     * @param input - The input data for the workflow
+     * @param options - Configuration options for the workflow run
+     * @returns A promise that resolves with the workflow result
+     */
+    run<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    /**
+     * Get the cron client for creating and managing cron workflow runs
+     * @returns A cron client instance
+     */
+    get crons(): import("../../clients/hatchet-client/features/cron-client").CronClient;
+    /**
+     * Get the cron client for creating and managing cron workflow runs
+     * @returns A cron client instance
+     * @deprecated use client.crons instead
+     */
     get cron(): import("../../clients/hatchet-client/features/cron-client").CronClient;
+    /**
+     * Get the schedules client for creating and managing scheduled workflow runs
+     * @returns A schedules client instance
+     */
+    get schedules(): import("../../clients/hatchet-client/features/schedule-client").ScheduleClient;
+    /**
+     * Get the schedule client for creating and managing scheduled workflow runs
+     * @returns A schedule client instance
+     * @deprecated use client.schedules instead
+     */
     get schedule(): import("../../clients/hatchet-client/features/schedule-client").ScheduleClient;
+    /**
+     * Get the event client for creating and managing event workflow runs
+     * @returns A event client instance
+     */
+    get events(): import("../../clients/event/event-client").EventClient;
+    /**
+     * Get the event client for creating and managing event workflow runs
+     * @returns A event client instance
+     * @deprecated use client.events instead
+     */
     get event(): import("../../clients/event/event-client").EventClient;
+    private _metrics;
+    /**
+     * Get the metrics client for creating and managing metrics
+     * @returns A metrics client instance
+     */
+    get metrics(): MetricsClient;
+    private _runs;
+    /**
+     * Get the runs client for creating and managing runs
+     * @returns A runs client instance
+     */
+    get runs(): RunsClient;
+    private _workflows;
+    /**
+     * Get the workflows client for creating and managing workflows
+     * @returns A workflows client instance
+     */
+    get workflows(): WorkflowsClient;
+    private _workers;
+    /**
+     * Get the workers client for creating and managing workers
+     * @returns A workers client instance
+     */
+    get workers(): WorkersClient;
+    /**
+     * Get the API client for making HTTP requests to the Hatchet API
+     * Note: This is not recommended for general use, but is available for advanced scenarios
+     * @returns A API client instance
+     */
     get api(): import("../..").Api<unknown>;
     /**
-     * @deprecated use workflow.run or client.run instead
+     * @deprecated use workflow.run, client.run, or client.* feature methods instead
      */
     get admin(): import("../..").AdminClient;
     /**
@@ -78,5 +195,6 @@ export declare class HatchetClient implements IHatchetClient {
      * @param workflows - The workflows to register on the webhooks
      * @returns A promise that resolves when the webhook is registered
      */
-    webhooks(workflows: WorkflowDeclaration<any, any>[] | V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
+    webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
+    runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }

package/v1/client/client.interface.d.ts

@@ -1,4 +1,12 @@
 import { InternalHatchetClient } from '../../clients/hatchet-client';
+import { MetricsClient } from './features/metrics';
+import { RunsClient } from './features/runs';
+import { WorkersClient } from './features/workers';
+import { WorkflowsClient } from './features/workflows';
 export interface IHatchetClient {
-    v0: InternalHatchetClient;
+    _v0: InternalHatchetClient;
+    metrics: MetricsClient;
+    runs: RunsClient;
+    workflows: WorkflowsClient;
+    workers: WorkersClient;
 }

package/v1/client/client.js

@@ -8,19 +8,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetClient = void 0;
+/* eslint-disable no-dupe-class-members */
+/* eslint-disable no-underscore-dangle */
 const hatchet_client_1 = require("../../clients/hatchet-client");
-const workflow_1 = require("../workflow");
+const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
+const declaration_1 = require("../declaration");
 const worker_1 = require("./worker");
+const metrics_1 = require("./features/metrics");
+const workers_1 = require("./features/workers");
+const workflows_1 = require("./features/workflows");
+const runs_1 = require("./features/runs");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
  */
 class HatchetClient {
+    /**
+     * @deprecated v0 client will be removed in a future release, please upgrade to v1
+     */
+    get v0() {
+        return this._v0;
+    }
     /** The tenant ID for the Hatchet client */
     get tenantId() {
-        return this.v0.tenantId;
+        return this._v0.tenantId;
+    }
+    get isV1() {
+        return true;
     }
     /**
      * Creates a new Hatchet client instance.
@@ -29,7 +48,8 @@ class HatchetClient {
      * @param axiosConfig - Optional Axios configuration for HTTP requests
      */
     constructor(config, options, axiosConfig) {
-        this.v0 = new hatchet_client_1.InternalHatchetClient(config, options, axiosConfig);
+        this._isV1 = true;
+        this._v0 = new hatchet_client_1.InternalHatchetClient(config, options, axiosConfig);
     }
     /**
      * Static factory method to create a new Hatchet client instance.
@@ -50,7 +70,19 @@ class HatchetClient {
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
     workflow(options) {
-        return (0, workflow_1.CreateWorkflow)(options, this);
+        return (0, declaration_1.CreateWorkflow)(options, this);
+    }
+    /**
+     * Implementation of the task method.
+     */
+    task(options) {
+        return (0, declaration_1.CreateTaskWorkflow)(options, this);
+    }
+    /**
+     * Implementation of the durableTask method.
+     */
+    durableTask(options) {
+        return (0, declaration_1.CreateDurableTaskWorkflow)(options, this);
     }
     /**
      * Triggers a workflow run without waiting for completion.
@@ -61,7 +93,7 @@ class HatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    enqueue(workflow, input, options) {
+    runNoWait(workflow, input, options) {
         let name;
         if (typeof workflow === 'string') {
             name = workflow;
@@ -72,9 +104,10 @@ class HatchetClient {
         else {
             throw new Error('unable to identify workflow');
         }
-        return this.v0.admin.runWorkflow(name, input, options);
+        return this._v0.admin.runWorkflow(name, input, options);
     }
     /**
+     * @alias run
      * Triggers a workflow run and waits for the result.
      * @template T - The input type for the workflow
      * @template K - The return type of the workflow
@@ -83,29 +116,124 @@ class HatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    run(workflow_2, input_1) {
+    runAndWait(workflow_1, input_1) {
         return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
-            const run = this.enqueue(workflow, input, options);
-            return run.result();
+            return this.run(workflow, input, options);
         });
     }
+    /**
+     * Triggers a workflow run and waits for the result.
+     * @template T - The input type for the workflow
+     * @template K - The return type of the workflow
+     * @param workflow - The workflow to run, either as a Workflow instance or workflow name
+     * @param input - The input data for the workflow
+     * @param options - Configuration options for the workflow run
+     * @returns A promise that resolves with the workflow result
+     */
+    run(workflow_1, input_1) {
+        return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
+            const run = this.runNoWait(workflow, input, options);
+            return run.output;
+        });
+    }
+    /**
+     * Get the cron client for creating and managing cron workflow runs
+     * @returns A cron client instance
+     */
+    get crons() {
+        return this._v0.cron;
+    }
+    /**
+     * Get the cron client for creating and managing cron workflow runs
+     * @returns A cron client instance
+     * @deprecated use client.crons instead
+     */
     get cron() {
-        return this.v0.cron;
+        return this.crons;
     }
+    /**
+     * Get the schedules client for creating and managing scheduled workflow runs
+     * @returns A schedules client instance
+     */
+    get schedules() {
+        return this._v0.schedule;
+    }
+    /**
+     * Get the schedule client for creating and managing scheduled workflow runs
+     * @returns A schedule client instance
+     * @deprecated use client.schedules instead
+     */
     get schedule() {
-        return this.v0.schedule;
+        return this.schedules;
+    }
+    /**
+     * Get the event client for creating and managing event workflow runs
+     * @returns A event client instance
+     */
+    get events() {
+        return this._v0.event;
     }
+    /**
+     * Get the event client for creating and managing event workflow runs
+     * @returns A event client instance
+     * @deprecated use client.events instead
+     */
     get event() {
-        return this.v0.event;
+        return this.events;
+    }
+    /**
+     * Get the metrics client for creating and managing metrics
+     * @returns A metrics client instance
+     */
+    get metrics() {
+        if (!this._metrics) {
+            this._metrics = new metrics_1.MetricsClient(this);
+        }
+        return this._metrics;
+    }
+    /**
+     * Get the runs client for creating and managing runs
+     * @returns A runs client instance
+     */
+    get runs() {
+        if (!this._runs) {
+            this._runs = new runs_1.RunsClient(this);
+        }
+        return this._runs;
+    }
+    /**
+     * Get the workflows client for creating and managing workflows
+     * @returns A workflows client instance
+     */
+    get workflows() {
+        if (!this._workflows) {
+            this._workflows = new workflows_1.WorkflowsClient(this);
+        }
+        return this._workflows;
     }
+    /**
+     * Get the workers client for creating and managing workers
+     * @returns A workers client instance
+     */
+    get workers() {
+        if (!this._workers) {
+            this._workers = new workers_1.WorkersClient(this);
+        }
+        return this._workers;
+    }
+    /**
+     * Get the API client for making HTTP requests to the Hatchet API
+     * Note: This is not recommended for general use, but is available for advanced scenarios
+     * @returns A API client instance
+     */
     get api() {
-        return this.v0.api;
+        return this._v0.api;
     }
     /**
-     * @deprecated use workflow.run or client.run instead
+     * @deprecated use workflow.run, client.run, or client.* feature methods instead
      */
     get admin() {
-        return this.v0.admin;
+        return this._v0.admin;
     }
     /**
      * Creates a new worker instance for processing workflow tasks.
@@ -120,7 +248,7 @@ class HatchetClient {
         else {
             opts = options || {};
         }
-        return worker_1.Worker.create(this.v0, name, opts);
+        return worker_1.Worker.create(this, this._v0, name, opts);
     }
     /**
      * Register a webhook with the worker
@@ -128,7 +256,10 @@ class HatchetClient {
      * @returns A promise that resolves when the webhook is registered
      */
     webhooks(workflows) {
-        return this.v0.webhooks(workflows);
+        return this._v0.webhooks(workflows);
+    }
+    runRef(id) {
+        return new workflow_run_ref_1.default(id, this.v0.listener);
     }
 }
 exports.HatchetClient = HatchetClient;

package/v1/client/duration.d.ts

@@ -0,0 +1,7 @@
+type SecondsDuration = `${number}s`;
+type MinutesDuration = `${number}m`;
+type HoursDuration = `${number}h`;
+type TwoUnitDurations = `${number}h${number}m` | `${number}h${number}s` | `${number}m${number}s`;
+type ThreeUnitDurations = `${number}h${number}m${number}s`;
+export type Duration = SecondsDuration | MinutesDuration | HoursDuration | TwoUnitDurations | ThreeUnitDurations;
+export {};

package/v1/client/duration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/v1/client/features/index.d.ts

@@ -0,0 +1,5 @@
+export * from './metrics';
+export * from './ratelimits';
+export * from './runs';
+export * from './workers';
+export * from './workflows';

package/v1/client/features/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./metrics"), exports);
+__exportStar(require("./ratelimits"), exports);
+__exportStar(require("./runs"), exports);
+__exportStar(require("./workers"), exports);
+__exportStar(require("./workflows"), exports);

package/v1/client/features/metrics.d.ts

@@ -0,0 +1,14 @@
+import { BaseWorkflowDeclaration } from '../..';
+import { Workflow } from '../../../workflow';
+import { HatchetClient } from '../client';
+/**
+ * MetricsClient is used to get metrics for workflows
+ */
+export declare class MetricsClient {
+    tenantId: string;
+    api: HatchetClient['api'];
+    constructor(client: HatchetClient);
+    getWorkflowMetrics(workflow: string | Workflow | BaseWorkflowDeclaration<any, any>, opts?: Parameters<typeof this.api.workflowGetMetrics>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowMetrics>;
+    getQueueMetrics(opts?: Parameters<typeof this.api.tenantGetQueueMetrics>[1] & {}): Promise<import("../../../clients/rest/generated/data-contracts").TenantQueueMetrics>;
+    getTaskMetrics(opts?: Parameters<typeof this.api.tenantGetStepRunQueueMetrics>[1]): Promise<import("../../../clients/rest/generated/data-contracts").TenantStepRunQueueMetrics>;
+}

package/v1/client/features/metrics.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsClient = void 0;
+const v1_1 = require("../..");
+/**
+ * MetricsClient is used to get metrics for workflows
+ */
+class MetricsClient {
+    constructor(client) {
+        this.tenantId = client.tenantId;
+        this.api = client.api;
+    }
+    getWorkflowMetrics(workflow, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = (0, v1_1.workflowNameString)(workflow);
+            const { data } = yield this.api.workflowGetMetrics(name, opts);
+            return data;
+        });
+    }
+    getQueueMetrics(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO IMPORTANT workflow id is the uuid for the workflow... not its name
+            // const stringWorkflows = opts?.workflows?
+            const { data } = yield this.api.tenantGetQueueMetrics(this.tenantId, Object.assign({}, opts));
+            return data;
+        });
+    }
+    getTaskMetrics(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO what is this...
+            const { data } = yield this.api.tenantGetStepRunQueueMetrics(this.tenantId, opts);
+            return data;
+        });
+    }
+}
+exports.MetricsClient = MetricsClient;

package/v1/client/features/ratelimits.d.ts

@@ -0,0 +1,20 @@
+import { RateLimitDuration } from '../../../protoc/workflows';
+import { RateLimitOrderByField, RateLimitOrderByDirection } from '../../../clients/rest/generated/data-contracts';
+import { HatchetClient } from '../client';
+export { RateLimitDuration, RateLimitOrderByField, RateLimitOrderByDirection };
+export type CreateRateLimitOpts = {
+    key: string;
+    limit: number;
+    duration?: RateLimitDuration;
+};
+/**
+ * RatelimitsClient is used to manage rate limits for the Hatchet
+ */
+export declare class RatelimitsClient {
+    api: HatchetClient['api'];
+    admin: HatchetClient['admin'];
+    tenantId: string;
+    constructor(client: HatchetClient);
+    upsert(opts: CreateRateLimitOpts): Promise<string>;
+    list(opts: Parameters<typeof this.api.rateLimitList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").RateLimitList>;
+}

package/v1/client/features/ratelimits.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatelimitsClient = exports.RateLimitOrderByDirection = exports.RateLimitOrderByField = exports.RateLimitDuration = void 0;
+const workflows_1 = require("../../../protoc/workflows");
+Object.defineProperty(exports, "RateLimitDuration", { enumerable: true, get: function () { return workflows_1.RateLimitDuration; } });
+const data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+Object.defineProperty(exports, "RateLimitOrderByField", { enumerable: true, get: function () { return data_contracts_1.RateLimitOrderByField; } });
+Object.defineProperty(exports, "RateLimitOrderByDirection", { enumerable: true, get: function () { return data_contracts_1.RateLimitOrderByDirection; } });
+/**
+ * RatelimitsClient is used to manage rate limits for the Hatchet
+ */
+class RatelimitsClient {
+    constructor(client) {
+        this.api = client.api;
+        this.admin = client.admin;
+        this.tenantId = client.tenantId;
+    }
+    upsert(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.admin.putRateLimit(opts.key, opts.limit, opts.duration);
+            return opts.key;
+        });
+    }
+    list(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.rateLimitList(this.tenantId, opts);
+            return data;
+        });
+    }
+}
+exports.RatelimitsClient = RatelimitsClient;

package/v1/client/features/runs.d.ts

@@ -0,0 +1,15 @@
+import WorkflowRunRef from '../../../util/workflow-run-ref';
+import { HatchetClient } from '../client';
+/**
+ * RunsClient is used to list and manage runs
+ */
+export declare class RunsClient {
+    api: HatchetClient['api'];
+    tenantId: string;
+    constructor(client: HatchetClient);
+    get<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRun>;
+    getDetails<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunShape>;
+    list(opts?: Parameters<typeof this.api.workflowRunList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunList>;
+    replay(opts: Parameters<typeof this.api.v1TaskReplay>[1]): Promise<void>;
+    cancel(opts: Parameters<typeof this.api.v1TaskCancel>[1]): Promise<void>;
+}