@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/{protoc → src/protoc}/workflows/workflows.js

@@ -5,7 +5,7 @@
 //   protoc               v3.19.1
 // source: workflows/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowServiceDefinition = exports.PutRateLimitResponse = exports.PutRateLimitRequest = exports.TriggerWorkflowResponse = exports.TriggerWorkflowRequest = exports.BulkTriggerWorkflowResponse = exports.BulkTriggerWorkflowRequest = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowVersion = exports.ScheduledWorkflow = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateStepRateLimit = exports.CreateWorkflowStepOpts_WorkerLabelsEntry = exports.CreateWorkflowStepOpts = exports.DesiredWorkerLabels = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.RateLimitDuration = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.WorkflowKind = exports.StickyStrategy = exports.protobufPackage = void 0;
+exports.WorkflowServiceDefinition = exports.PutRateLimitResponse = exports.PutRateLimitRequest = exports.TriggerWorkflowResponse = exports.TriggerWorkflowRequest_DesiredWorkerLabelsEntry = exports.TriggerWorkflowRequest = exports.BulkTriggerWorkflowResponse = exports.BulkTriggerWorkflowRequest = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowVersion = exports.ScheduledWorkflow = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateStepRateLimit = exports.CreateWorkflowStepOpts_WorkerLabelsEntry = exports.CreateWorkflowStepOpts = exports.DesiredWorkerLabels = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.RateLimitDuration = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.WorkflowKind = exports.StickyStrategy = exports.protobufPackage = void 0;
 exports.stickyStrategyFromJSON = stickyStrategyFromJSON;
 exports.stickyStrategyToJSON = stickyStrategyToJSON;
 exports.workflowKindFromJSON = workflowKindFromJSON;
@@ -2078,6 +2078,7 @@ function createBaseTriggerWorkflowRequest() {
         additionalMetadata: undefined,
         desiredWorkerId: undefined,
         priority: undefined,
+        desiredWorkerLabels: {},
     };
 }
 exports.TriggerWorkflowRequest = {
@@ -2109,6 +2110,9 @@ exports.TriggerWorkflowRequest = {
         if (message.priority !== undefined) {
             writer.uint32(72).int32(message.priority);
         }
+        Object.entries(message.desiredWorkerLabels).forEach(([key, value]) => {
+            exports.TriggerWorkflowRequest_DesiredWorkerLabelsEntry.encode({ key: key, value }, writer.uint32(82).fork()).join();
+        });
         return writer;
     },
     decode(input, length) {
@@ -2181,6 +2185,16 @@ exports.TriggerWorkflowRequest = {
                     message.priority = reader.int32();
                     continue;
                 }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    const entry10 = exports.TriggerWorkflowRequest_DesiredWorkerLabelsEntry.decode(reader, reader.uint32());
+                    if (entry10.value !== undefined) {
+                        message.desiredWorkerLabels[entry10.key] = entry10.value;
+                    }
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -2206,6 +2220,12 @@ exports.TriggerWorkflowRequest = {
                 ? globalThis.String(object.desiredWorkerId)
                 : undefined,
             priority: isSet(object.priority) ? globalThis.Number(object.priority) : undefined,
+            desiredWorkerLabels: isObject(object.desiredWorkerLabels)
+                ? Object.entries(object.desiredWorkerLabels).reduce((acc, [key, value]) => {
+                    acc[key] = exports.DesiredWorkerLabels.fromJSON(value);
+                    return acc;
+                }, {})
+                : {},
         };
     },
     toJSON(message) {
@@ -2237,13 +2257,22 @@ exports.TriggerWorkflowRequest = {
         if (message.priority !== undefined) {
             obj.priority = Math.round(message.priority);
         }
+        if (message.desiredWorkerLabels) {
+            const entries = Object.entries(message.desiredWorkerLabels);
+            if (entries.length > 0) {
+                obj.desiredWorkerLabels = {};
+                entries.forEach(([k, v]) => {
+                    obj.desiredWorkerLabels[k] = exports.DesiredWorkerLabels.toJSON(v);
+                });
+            }
+        }
         return obj;
     },
     create(base) {
         return exports.TriggerWorkflowRequest.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const message = createBaseTriggerWorkflowRequest();
         message.name = (_a = object.name) !== null && _a !== void 0 ? _a : '';
         message.input = (_b = object.input) !== null && _b !== void 0 ? _b : '';
@@ -2254,6 +2283,84 @@ exports.TriggerWorkflowRequest = {
         message.additionalMetadata = (_g = object.additionalMetadata) !== null && _g !== void 0 ? _g : undefined;
         message.desiredWorkerId = (_h = object.desiredWorkerId) !== null && _h !== void 0 ? _h : undefined;
         message.priority = (_j = object.priority) !== null && _j !== void 0 ? _j : undefined;
+        message.desiredWorkerLabels = Object.entries((_k = object.desiredWorkerLabels) !== null && _k !== void 0 ? _k : {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = exports.DesiredWorkerLabels.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseTriggerWorkflowRequest_DesiredWorkerLabelsEntry() {
+    return { key: '', value: undefined };
+}
+exports.TriggerWorkflowRequest_DesiredWorkerLabelsEntry = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            exports.DesiredWorkerLabels.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTriggerWorkflowRequest_DesiredWorkerLabelsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = exports.DesiredWorkerLabels.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : '',
+            value: isSet(object.value) ? exports.DesiredWorkerLabels.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== '') {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = exports.DesiredWorkerLabels.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TriggerWorkflowRequest_DesiredWorkerLabelsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseTriggerWorkflowRequest_DesiredWorkerLabelsEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : '';
+        message.value =
+            object.value !== undefined && object.value !== null
+                ? exports.DesiredWorkerLabels.fromPartial(object.value)
+                : undefined;
         return message;
     },
 };

package/src/sdk.d.ts

@@ -0,0 +1,2 @@
+import { HatchetClient as Hatchet } from '../v1/client/client';
+export default Hatchet;

package/{sdk.js → src/sdk.js}

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("./v1/client/client");
+const client_1 = require("../v1/client/client");
 exports.default = client_1.HatchetClient;

package/src/step.d.ts

@@ -0,0 +1 @@
+export * from './legacy/step';

package/{clients/worker/index.js → src/step.js}

@@ -14,4 +14,7 @@ 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("./worker"), exports);
+__exportStar(require("./legacy/step"), exports);
+console.warn('\x1b[31mDeprecation warning: The v0 sdk, including the step module has been deprecated and has been removed in release v1.14.0.\x1b[0m');
+console.warn('\x1b[32mPlease migrate to v1 SDK instead: https://docs.hatchet.run/home/v1-sdk-improvements\x1b[0m');
+console.warn('--------------------------------');

package/src/util/abort-error.d.ts

@@ -0,0 +1,38 @@
+export declare function createAbortError(message?: string): Error;
+export declare function isAbortError(err: unknown): err is Error;
+/**
+ * Helper to be used inside broad `catch` blocks so cancellation isn't accidentally swallowed.
+ *
+ * Example:
+ * ```ts
+ * try { ... } catch (e) { rethrowIfAborted(e); ... }
+ * ```
+ */
+export declare function rethrowIfAborted(err: unknown): void;
+export type ThrowIfAbortedOpts = {
+    /**
+     * Optional: called before throwing when the signal is aborted.
+     * This lets callsites attach logging without coupling this util to a logger implementation.
+     */
+    warn?: (message: string) => void;
+    /**
+     * If true, emits a generic warning intended for "trigger/enqueue" paths.
+     */
+    isTrigger?: boolean;
+    /**
+     * Optional context used to make warnings consistent, e.g. "task run <id>".
+     */
+    context?: string;
+    /**
+     * Message used when the AbortSignal doesn't provide a reason.
+     */
+    defaultMessage?: string;
+};
+/**
+ * Throws an AbortError if the provided signal is aborted.
+ *
+ * Notes:
+ * - In JS/TS, `catch` can swallow any thrown value, so this is best-effort.
+ * - We prefer throwing the signal's `reason` when it is already an Error.
+ */
+export declare function throwIfAborted(signal: AbortSignal | undefined, optsOrDefaultMessage?: ThrowIfAbortedOpts | string): void;

package/src/util/abort-error.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbortError = createAbortError;
+exports.isAbortError = isAbortError;
+exports.rethrowIfAborted = rethrowIfAborted;
+exports.throwIfAborted = throwIfAborted;
+function createAbortError(message = 'Operation aborted') {
+    const err = new Error(message);
+    err.name = 'AbortError';
+    err.code = 'ABORT_ERR';
+    return err;
+}
+function isAbortError(err) {
+    return err instanceof Error && (err.name === 'AbortError' || err.code === 'ABORT_ERR');
+}
+/**
+ * Helper to be used inside broad `catch` blocks so cancellation isn't accidentally swallowed.
+ *
+ * Example:
+ * ```ts
+ * try { ... } catch (e) { rethrowIfAborted(e); ... }
+ * ```
+ */
+function rethrowIfAborted(err) {
+    if (isAbortError(err)) {
+        throw err;
+    }
+}
+/**
+ * Throws an AbortError if the provided signal is aborted.
+ *
+ * Notes:
+ * - In JS/TS, `catch` can swallow any thrown value, so this is best-effort.
+ * - We prefer throwing the signal's `reason` when it is already an Error.
+ */
+function throwIfAborted(signal, optsOrDefaultMessage = 'Operation cancelled by AbortSignal') {
+    var _a, _b;
+    if (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+        return;
+    }
+    const opts = typeof optsOrDefaultMessage === 'string'
+        ? { defaultMessage: optsOrDefaultMessage }
+        : (optsOrDefaultMessage !== null && optsOrDefaultMessage !== void 0 ? optsOrDefaultMessage : {});
+    if (opts.isTrigger) {
+        const ctx = opts.context ? `${opts.context} ` : '';
+        (_a = opts.warn) === null || _a === void 0 ? void 0 : _a.call(opts, `Cancellation: ${ctx}attempted to enqueue/trigger work after cancellation was signaled. ` +
+            `This usually means an AbortError was caught and not propagated. ` +
+            `See https://docs.hatchet.run/home/cancellation`);
+    }
+    const { reason } = signal;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    if (typeof reason === 'string' && reason.length > 0) {
+        throw createAbortError(reason);
+    }
+    throw createAbortError((_b = opts.defaultMessage) !== null && _b !== void 0 ? _b : 'Operation cancelled by AbortSignal');
+}

package/{util → src/util}/config-loader/config-loader.d.ts

@@ -1,4 +1,4 @@
-import { ClientConfig } from '../../clients/hatchet-client';
+import { ClientConfig } from '../../../clients/hatchet-client';
 import { ChannelCredentials } from 'nice-grpc';
 interface LoadClientConfigOptions {
     path?: string;

package/{util → src/util}/config-loader/config-loader.js

@@ -38,7 +38,7 @@ const yaml_1 = require("yaml");
 const fs_1 = require("fs");
 const p = __importStar(require("path"));
 const zod_1 = require("zod");
-const hatchet_client_1 = require("../../clients/hatchet-client");
+const hatchet_client_1 = require("../../../clients/hatchet-client");
 const nice_grpc_1 = require("nice-grpc");
 const token_1 = require("./token");
 const DEFAULT_CONFIG_FILE = '.hatchet.yaml';

package/{util → src/util}/grpc-helpers.d.ts

@@ -1,4 +1,4 @@
-import { ClientConfig } from '../clients/hatchet-client';
+import { ClientConfig } from '../../clients/hatchet-client';
 import { ChannelCredentials, CompatServiceDefinition } from 'nice-grpc';
 import { ClientMiddlewareCall, CallOptions } from 'nice-grpc-common';
 export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;

package/src/util/hatchet-promise/hatchet-promise.d.ts

@@ -0,0 +1,13 @@
+declare class HatchetPromise<T> {
+    cancel: (reason?: any) => void;
+    promise: Promise<T>;
+    /**
+     * The original (non-cancelable) promise passed to the constructor.
+     *
+     * `promise` is a cancelable wrapper which rejects immediately when `cancel` is called.
+     * `inner` continues executing and will settle when the underlying work completes.
+     */
+    inner: Promise<T>;
+    constructor(promise: Promise<T>);
+}
+export default HatchetPromise;

package/{util → src/util}/hatchet-promise/hatchet-promise.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 class HatchetPromise {
     constructor(promise) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.cancel = (reason) => { };
+        this.cancel = (_reason) => { };
+        this.inner = Promise.resolve(promise);
         this.promise = new Promise((resolve, reject) => {
             this.cancel = reject;
-            Promise.resolve(promise).then(resolve).catch(reject);
+            this.inner.then(resolve).catch(reject);
         });
     }
 }

package/src/util/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logger';
+export * from './task-run-log';

package/{util → src/util}/logger/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./logger"), exports);
+__exportStar(require("./task-run-log"), exports);

package/{util → src/util}/logger/logger.d.ts

@@ -1,4 +1,4 @@
-import { JsonObject } from '../../v1';
+import { JsonObject } from '../../../v1';
 export type LogExtra = JsonObject;
 export declare abstract class Logger {
     abstract debug(message: string, extra?: LogExtra): void | Promise<void>;

package/src/util/logger/task-run-log.d.ts

@@ -0,0 +1,3 @@
+import { ActionType } from '../../protoc/dispatcher';
+export declare function actionMap(action: ActionType): string;
+export declare function taskRunLog(taskName: string, taskRunExternalId: string, action: string): string;

package/src/util/logger/task-run-log.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionMap = actionMap;
+exports.taskRunLog = taskRunLog;
+const dispatcher_1 = require("../../protoc/dispatcher");
+function actionMap(action) {
+    switch (action) {
+        case dispatcher_1.ActionType.START_STEP_RUN:
+            return 'starting...';
+        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
+            return 'cancelling...';
+        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
+            return 'starting to get group key...';
+        default:
+            return 'unknown';
+    }
+}
+function taskRunLog(taskName, taskRunExternalId, action) {
+    return `Task run ${action} \t ${taskName}/${taskRunExternalId} `;
+}

package/{util → src/util}/sleep.d.ts

@@ -3,8 +3,11 @@
  *
  * WARNING: This is not a durable sleep. It will not be honored if the worker is
  * restarted or crashes.
+ *
  * @param ms - The number of milliseconds to sleep
- * @returns A promise that resolves after the given number of milliseconds
+ * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
+ *                 Use in task handlers so cancellation can interrupt long sleeps.
+ * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
  */
-declare const sleep: (ms: number) => Promise<unknown>;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 export default sleep;

package/src/util/sleep.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Sleeps for a given number of milliseconds without blocking the event loop
+ *
+ * WARNING: This is not a durable sleep. It will not be honored if the worker is
+ * restarted or crashes.
+ *
+ * @param ms - The number of milliseconds to sleep
+ * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
+ *                 Use in task handlers so cancellation can interrupt long sleeps.
+ * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
+ */
+function sleep(ms, signal) {
+    if (!signal) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error('Cancelled'));
+        };
+        if (signal.aborted) {
+            clearTimeout(timer);
+            reject(new Error('Cancelled'));
+            return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+exports.default = sleep;

package/{util → src/util}/workflow-run-ref.d.ts

@@ -1,5 +1,5 @@
-import { RunListenerClient, StepRunEvent } from '../clients/listeners/run-listener/child-listener-client';
-import { RunsClient } from '../v1';
+import { RunListenerClient, StepRunEvent } from '../../clients/listeners/run-listener/child-listener-client';
+import { RunsClient } from '../../v1';
 type EventualWorkflowRunId = string | Promise<string> | Promise<{
     workflowRunId: string;
 }>;
@@ -12,9 +12,15 @@ export default class WorkflowRunRef<T> {
     private client;
     private runs;
     _standaloneTaskName?: string;
+    /**
+     * Optional default AbortSignal used for listener-backed waits (e.g. `.result()`).
+     * This is primarily set when a run is spawned from within a task so cancellations propagate
+     * without manually threading `{ signal }` everywhere.
+     */
+    defaultSignal?: AbortSignal;
     constructor(workflowRunId: string | Promise<string> | Promise<{
         workflowRunId: string;
-    }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string, standaloneTaskName?: string);
+    }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string, standaloneTaskName?: string, defaultSignal?: AbortSignal);
     get runId(): Promise<string>;
     getWorkflowRunId(): Promise<string>;
     stream(): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;

package/{util → src/util}/workflow-run-ref.js

@@ -50,12 +50,13 @@ function getWorkflowRunId(workflowRunId) {
     });
 }
 class WorkflowRunRef {
-    constructor(workflowRunId, client, runsClient, parentWorkflowRunId, standaloneTaskName) {
+    constructor(workflowRunId, client, runsClient, parentWorkflowRunId, standaloneTaskName, defaultSignal) {
         this.workflowRunId = workflowRunId;
         this.parentWorkflowRunId = parentWorkflowRunId;
         this.client = client;
         this.runs = runsClient;
         this._standaloneTaskName = standaloneTaskName;
+        this.defaultSignal = defaultSignal;
     }
     // TODO docstrings
     get runId() {
@@ -88,8 +89,9 @@ class WorkflowRunRef {
                 (() => __awaiter(this, void 0, void 0, function* () {
                     var _a, e_1, _b, _c;
                     var _d, _e;
+                    const signal = this.defaultSignal;
                     try {
-                        for (var _f = true, _g = __asyncValues(streamable.stream()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        for (var _f = true, _g = __asyncValues(streamable.stream({ signal })), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
                             _c = _h.value;
                             _f = false;
                             const event = _c;
@@ -143,7 +145,7 @@ class WorkflowRunRef {
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
-                }))();
+                }))().catch(reject);
             });
         });
     }

package/{v1 → src/v1}/client/admin.d.ts

@@ -1,10 +1,17 @@
-import { ClientConfig } from '../../clients/hatchet-client/client-config';
-import WorkflowRunRef from '../../util/workflow-run-ref';
-import { Priority, RateLimitDuration, RunsClient } from './..';
-import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
-import { Api } from '../../clients/rest/generated/Api';
-import { WorkflowServiceClient } from '../../protoc/workflows';
-import { Logger } from '../../util/logger';
+import { ClientConfig } from '../../../clients/hatchet-client/client-config';
+import WorkflowRunRef from '../../../util/workflow-run-ref';
+import { Priority, RateLimitDuration, RunsClient } from '../../../v1';
+import { RunListenerClient } from '../../../clients/listeners/run-listener/child-listener-client';
+import { Api } from '../../../clients/rest/generated/Api';
+import { WorkerLabelComparator, WorkflowServiceClient } from '../../../protoc/workflows';
+import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../../protoc/v1/workflows';
+import { Logger } from '../../../util/logger';
+type DesiredWorkerLabelOpt = {
+    value: string | number;
+    required?: boolean;
+    weight?: number;
+    comparator?: WorkerLabelComparator;
+};
 export type WorkflowRun<T = object> = {
     workflowName: string;
     input: T;
@@ -28,11 +35,17 @@ export type WorkflowRun<T = object> = {
 };
 export declare class AdminClient {
     config: ClientConfig;
-    grpc: WorkflowServiceClient;
+    workflowsGrpc: WorkflowServiceClient;
+    adminGrpc: AdminServiceClient;
     listenerClient: RunListenerClient;
     runs: RunsClient;
     logger: Logger;
     constructor(config: ClientConfig, api: Api, runs: RunsClient);
+    /**
+     * Creates a new workflow or updates an existing workflow via the v1 admin service.
+     * @param workflow a workflow definition to create
+     */
+    putWorkflow(workflow: CreateWorkflowVersionRequest): Promise<import("../../../protoc/v1/workflows").CreateWorkflowVersionResponse>;
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.
@@ -59,6 +72,7 @@ export declare class AdminClient {
         additionalMetadata?: Record<string, string> | undefined;
         desiredWorkerId?: string | undefined;
         priority?: Priority;
+        desiredWorkerLabels?: Record<string, DesiredWorkerLabelOpt>;
         _standaloneTaskName?: string | undefined;
     }): Promise<WorkflowRunRef<P>>;
     /**
@@ -88,8 +102,10 @@ export declare class AdminClient {
             additionalMetadata?: Record<string, string> | undefined;
             desiredWorkerId?: string | undefined;
             priority?: Priority;
+            desiredWorkerLabels?: Record<string, DesiredWorkerLabelOpt>;
             _standaloneTaskName?: string | undefined;
         };
     }>, batchSize?: number): Promise<WorkflowRunRef<P>[]>;
     putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
 }
+export {};