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

package/protoc/v1/workflows.d.ts

@@ -0,0 +1,263 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+import { type CallContext, type CallOptions } from 'nice-grpc-common';
+import { TaskConditions } from './shared/condition';
+export declare const protobufPackage = "v1";
+export declare enum StickyStrategy {
+    SOFT = 0,
+    HARD = 1,
+    UNRECOGNIZED = -1
+}
+export declare function stickyStrategyFromJSON(object: any): StickyStrategy;
+export declare function stickyStrategyToJSON(object: StickyStrategy): string;
+export declare enum RateLimitDuration {
+    SECOND = 0,
+    MINUTE = 1,
+    HOUR = 2,
+    DAY = 3,
+    WEEK = 4,
+    MONTH = 5,
+    YEAR = 6,
+    UNRECOGNIZED = -1
+}
+export declare function rateLimitDurationFromJSON(object: any): RateLimitDuration;
+export declare function rateLimitDurationToJSON(object: RateLimitDuration): string;
+export declare enum ConcurrencyLimitStrategy {
+    CANCEL_IN_PROGRESS = 0,
+    /** DROP_NEWEST - deprecated */
+    DROP_NEWEST = 1,
+    /** QUEUE_NEWEST - deprecated */
+    QUEUE_NEWEST = 2,
+    GROUP_ROUND_ROBIN = 3,
+    CANCEL_NEWEST = 4,
+    UNRECOGNIZED = -1
+}
+export declare function concurrencyLimitStrategyFromJSON(object: any): ConcurrencyLimitStrategy;
+export declare function concurrencyLimitStrategyToJSON(object: ConcurrencyLimitStrategy): string;
+export declare enum WorkerLabelComparator {
+    EQUAL = 0,
+    NOT_EQUAL = 1,
+    GREATER_THAN = 2,
+    GREATER_THAN_OR_EQUAL = 3,
+    LESS_THAN = 4,
+    LESS_THAN_OR_EQUAL = 5,
+    UNRECOGNIZED = -1
+}
+export declare function workerLabelComparatorFromJSON(object: any): WorkerLabelComparator;
+export declare function workerLabelComparatorToJSON(object: WorkerLabelComparator): string;
+export interface CancelTasksRequest {
+    /** a list of external UUIDs */
+    externalIds: string[];
+    filter?: TasksFilter | undefined;
+}
+export interface ReplayTasksRequest {
+    /** a list of external UUIDs */
+    externalIds: string[];
+    filter?: TasksFilter | undefined;
+}
+export interface TasksFilter {
+    statuses: string[];
+    since: Date | undefined;
+    until?: Date | undefined;
+    workflowIds: string[];
+    additionalMetadata: string[];
+}
+export interface CancelTasksResponse {
+    cancelledTasks: string[];
+}
+export interface ReplayTasksResponse {
+    replayedTasks: string[];
+}
+export interface TriggerWorkflowRunRequest {
+    workflowName: string;
+    input: Uint8Array;
+    additionalMetadata: Uint8Array;
+}
+export interface TriggerWorkflowRunResponse {
+    externalId: string;
+}
+/** CreateWorkflowVersionRequest represents options to create a workflow version. */
+export interface CreateWorkflowVersionRequest {
+    /** (required) the workflow name */
+    name: string;
+    /** (optional) the workflow description */
+    description: string;
+    /** (optional) the workflow version */
+    version: string;
+    /** (optional) event triggers for the workflow */
+    eventTriggers: string[];
+    /** (optional) cron triggers for the workflow */
+    cronTriggers: string[];
+    /** (required) the workflow jobs */
+    tasks: CreateTaskOpts[];
+    /** (optional) the workflow concurrency options */
+    concurrency: Concurrency | undefined;
+    /** (optional) the input for the cron trigger */
+    cronInput?: string | undefined;
+    /** (optional) the job to run on failure */
+    onFailureTask?: CreateTaskOpts | undefined;
+    /** (optional) the sticky strategy for assigning steps to workers */
+    sticky?: StickyStrategy | undefined;
+}
+export interface Concurrency {
+    /** (required) the expression to use for concurrency */
+    expression: string;
+    /** (optional) the maximum number of concurrent workflow runs, default 1 */
+    maxRuns?: number | undefined;
+    /** (optional) the strategy to use when the concurrency limit is reached, default CANCEL_IN_PROGRESS */
+    limitStrategy?: ConcurrencyLimitStrategy | undefined;
+}
+export interface DesiredWorkerLabels {
+    /** value of the affinity */
+    strValue?: string | undefined;
+    intValue?: number | undefined;
+    /**
+     * (optional) Specifies whether the affinity setting is required.
+     * If required, the worker will not accept actions that do not have a truthy affinity setting.
+     *
+     * Defaults to false.
+     */
+    required?: boolean | undefined;
+    /**
+     * (optional) Specifies the comparator for the affinity setting.
+     * If not set, the default is EQUAL.
+     */
+    comparator?: WorkerLabelComparator | undefined;
+    /**
+     * (optional) Specifies the weight of the affinity setting.
+     * If not set, the default is 100.
+     */
+    weight?: number | undefined;
+}
+/** CreateTaskOpts represents options to create a task. */
+export interface CreateTaskOpts {
+    /** (required) the task name */
+    readableId: string;
+    /** (required) the task action id */
+    action: string;
+    /** (optional) the task timeout */
+    timeout: string;
+    /** (optional) the task inputs, assuming string representation of JSON */
+    inputs: string;
+    /** (optional) the task parents. if none are passed in, this is a root task */
+    parents: string[];
+    /** (optional) the number of retries for the step, default 0 */
+    retries: number;
+    /** (optional) the rate limits for the step */
+    rateLimits: CreateTaskRateLimit[];
+    /** (optional) the desired worker affinity state for the step */
+    workerLabels: {
+        [key: string]: DesiredWorkerLabels;
+    };
+    /** (optional) the retry backoff factor for the step */
+    backoffFactor?: number | undefined;
+    /** (optional) the maximum backoff time for the step */
+    backoffMaxSeconds?: number | undefined;
+    /** (optional) the task concurrency options */
+    concurrency: Concurrency[];
+    /** (optional) the task conditions for creating the task */
+    conditions?: TaskConditions | undefined;
+    /** (optional) the timeout for the schedule */
+    scheduleTimeout?: string | undefined;
+}
+export interface CreateTaskOpts_WorkerLabelsEntry {
+    key: string;
+    value: DesiredWorkerLabels | undefined;
+}
+export interface CreateTaskRateLimit {
+    /** (required) the key for the rate limit */
+    key: string;
+    /** (optional) the number of units this step consumes */
+    units?: number | undefined;
+    /** (optional) a CEL expression for determining the rate limit key */
+    keyExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the number of units consumed */
+    unitsExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the total amount of rate limit units */
+    limitValuesExpr?: string | undefined;
+    /** (optional) the default rate limit window to use for dynamic rate limits */
+    duration?: RateLimitDuration | undefined;
+}
+/** CreateWorkflowVersionResponse represents the response after creating a workflow version. */
+export interface CreateWorkflowVersionResponse {
+    id: string;
+    workflowId: string;
+}
+export declare const CancelTasksRequest: MessageFns<CancelTasksRequest>;
+export declare const ReplayTasksRequest: MessageFns<ReplayTasksRequest>;
+export declare const TasksFilter: MessageFns<TasksFilter>;
+export declare const CancelTasksResponse: MessageFns<CancelTasksResponse>;
+export declare const ReplayTasksResponse: MessageFns<ReplayTasksResponse>;
+export declare const TriggerWorkflowRunRequest: MessageFns<TriggerWorkflowRunRequest>;
+export declare const TriggerWorkflowRunResponse: MessageFns<TriggerWorkflowRunResponse>;
+export declare const CreateWorkflowVersionRequest: MessageFns<CreateWorkflowVersionRequest>;
+export declare const Concurrency: MessageFns<Concurrency>;
+export declare const DesiredWorkerLabels: MessageFns<DesiredWorkerLabels>;
+export declare const CreateTaskOpts: MessageFns<CreateTaskOpts>;
+export declare const CreateTaskOpts_WorkerLabelsEntry: MessageFns<CreateTaskOpts_WorkerLabelsEntry>;
+export declare const CreateTaskRateLimit: MessageFns<CreateTaskRateLimit>;
+export declare const CreateWorkflowVersionResponse: MessageFns<CreateWorkflowVersionResponse>;
+/** AdminService represents a set of RPCs for admin management of tasks, workflows, etc. */
+export type AdminServiceDefinition = typeof AdminServiceDefinition;
+export declare const AdminServiceDefinition: {
+    readonly name: "AdminService";
+    readonly fullName: "v1.AdminService";
+    readonly methods: {
+        readonly putWorkflow: {
+            readonly name: "PutWorkflow";
+            readonly requestType: MessageFns<CreateWorkflowVersionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<CreateWorkflowVersionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly cancelTasks: {
+            readonly name: "CancelTasks";
+            readonly requestType: MessageFns<CancelTasksRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<CancelTasksResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly replayTasks: {
+            readonly name: "ReplayTasks";
+            readonly requestType: MessageFns<ReplayTasksRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ReplayTasksResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly triggerWorkflowRun: {
+            readonly name: "TriggerWorkflowRun";
+            readonly requestType: MessageFns<TriggerWorkflowRunRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<TriggerWorkflowRunResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface AdminServiceImplementation<CallContextExt = {}> {
+    putWorkflow(request: CreateWorkflowVersionRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CreateWorkflowVersionResponse>>;
+    cancelTasks(request: CancelTasksRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CancelTasksResponse>>;
+    replayTasks(request: ReplayTasksRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ReplayTasksResponse>>;
+    triggerWorkflowRun(request: TriggerWorkflowRunRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TriggerWorkflowRunResponse>>;
+}
+export interface AdminServiceClient<CallOptionsExt = {}> {
+    putWorkflow(request: DeepPartial<CreateWorkflowVersionRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateWorkflowVersionResponse>;
+    cancelTasks(request: DeepPartial<CancelTasksRequest>, options?: CallOptions & CallOptionsExt): Promise<CancelTasksResponse>;
+    replayTasks(request: DeepPartial<ReplayTasksRequest>, options?: CallOptions & CallOptionsExt): Promise<ReplayTasksResponse>;
+    triggerWorkflowRun(request: DeepPartial<TriggerWorkflowRunRequest>, options?: CallOptions & CallOptionsExt): Promise<TriggerWorkflowRunResponse>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};