@hatchet-dev/typescript-sdk 0.1.31 → 0.2.1

package/protoc/dispatcher/dispatcher.d.ts

@@ -1,5 +1,5 @@
-import type { CallContext, CallOptions } from "nice-grpc-common";
-import * as _m0 from "protobufjs/minimal";
+import type { CallContext, CallOptions } from 'nice-grpc-common';
+import * as _m0 from 'protobufjs/minimal';
 export declare const protobufPackage = "";
 export declare enum ActionType {
     START_STEP_RUN = 0,
@@ -161,6 +161,10 @@ export interface WorkflowEvent {
      * will hang up the connection but clients might want to case
      */
     hangup: boolean;
+    /** (optional) the max number of retries this step can handle */
+    stepRetries?: number | undefined;
+    /** (optional) the retry count of this step */
+    retryCount?: number | undefined;
 }
 export interface OverridesData {
     /** the step run id */
@@ -174,6 +178,14 @@ export interface OverridesData {
 }
 export interface OverridesDataResponse {
 }
+export interface HeartbeatRequest {
+    /** the id of the worker */
+    workerId: string;
+    /** heartbeatAt is the time the worker sent the heartbeat */
+    heartbeatAt: Date | undefined;
+}
+export interface HeartbeatResponse {
+}
 export declare const WorkerRegisterRequest: {
     encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
@@ -278,6 +290,22 @@ export declare const OverridesDataResponse: {
     create(base?: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
     fromPartial(_: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
 };
+export declare const HeartbeatRequest: {
+    encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+    fromJSON(object: any): HeartbeatRequest;
+    toJSON(message: HeartbeatRequest): unknown;
+    create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+    fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+};
+export declare const HeartbeatResponse: {
+    encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+    fromJSON(_: any): HeartbeatResponse;
+    toJSON(_: HeartbeatResponse): unknown;
+    create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+    fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+};
 export type DispatcherDefinition = typeof DispatcherDefinition;
 export declare const DispatcherDefinition: {
     readonly name: "Dispatcher";
@@ -327,6 +355,55 @@ export declare const DispatcherDefinition: {
             readonly responseStream: true;
             readonly options: {};
         };
+        /**
+         * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+         * against engine version v0.18.1+
+         */
+        readonly listenV2: {
+            readonly name: "ListenV2";
+            readonly requestType: {
+                encode(message: WorkerListenRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerListenRequest;
+                fromJSON(object: any): WorkerListenRequest;
+                toJSON(message: WorkerListenRequest): unknown;
+                create(base?: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+                fromPartial(object: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: AssignedAction, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): AssignedAction;
+                fromJSON(object: any): AssignedAction;
+                toJSON(message: AssignedAction): unknown;
+                create(base?: DeepPartial<AssignedAction>): AssignedAction;
+                fromPartial(object: DeepPartial<AssignedAction>): AssignedAction;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+        readonly heartbeat: {
+            readonly name: "Heartbeat";
+            readonly requestType: {
+                encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+                fromJSON(object: any): HeartbeatRequest;
+                toJSON(message: HeartbeatRequest): unknown;
+                create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+                fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+                fromJSON(_: any): HeartbeatResponse;
+                toJSON(_: HeartbeatResponse): unknown;
+                create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+                fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly subscribeToWorkflowEvents: {
             readonly name: "SubscribeToWorkflowEvents";
             readonly requestType: {
@@ -442,6 +519,13 @@ export declare const DispatcherDefinition: {
 export interface DispatcherServiceImplementation<CallContextExt = {}> {
     register(request: WorkerRegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerRegisterResponse>>;
     listen(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: HeartbeatRequest, context: CallContext & CallContextExt): Promise<DeepPartial<HeartbeatResponse>>;
     subscribeToWorkflowEvents(request: SubscribeToWorkflowEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowEvent>>;
     sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
@@ -451,6 +535,13 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
 export interface DispatcherClient<CallOptionsExt = {}> {
     register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
     listen(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: DeepPartial<HeartbeatRequest>, options?: CallOptions & CallOptionsExt): Promise<HeartbeatResponse>;
     subscribeToWorkflowEvents(request: DeepPartial<SubscribeToWorkflowEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowEvent>;
     sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;