@superdurable/dex 0.2.10 → 0.3.1

package/dist/src/gen/dex.js

@@ -1045,6 +1045,12 @@ function createBaseStepOptions() {
         waitForLockAttributeKeys: [],
         executeLockAttributeKeys: [],
         heartbeatTimeoutSeconds: 0,
+        waitForLoadAttributeMapInstances: [],
+        waitForLoadChannelNames: [],
+        waitForLoadChannelMapInstances: [],
+        executeLoadAttributeMapInstances: [],
+        executeLoadChannelNames: [],
+        executeLoadChannelMapInstances: [],
     };
 }
 export const StepOptions = {
@@ -1091,6 +1097,24 @@ export const StepOptions = {
         if (message.heartbeatTimeoutSeconds !== 0) {
             writer.uint32(112).int32(message.heartbeatTimeoutSeconds);
         }
+        for (const v of message.waitForLoadAttributeMapInstances) {
+            writer.uint32(122).string(v);
+        }
+        for (const v of message.waitForLoadChannelNames) {
+            writer.uint32(130).string(v);
+        }
+        for (const v of message.waitForLoadChannelMapInstances) {
+            writer.uint32(138).string(v);
+        }
+        for (const v of message.executeLoadAttributeMapInstances) {
+            writer.uint32(146).string(v);
+        }
+        for (const v of message.executeLoadChannelNames) {
+            writer.uint32(154).string(v);
+        }
+        for (const v of message.executeLoadChannelMapInstances) {
+            writer.uint32(162).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1198,6 +1222,48 @@ export const StepOptions = {
                     message.heartbeatTimeoutSeconds = reader.int32();
                     continue;
                 }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.waitForLoadAttributeMapInstances.push(reader.string());
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.waitForLoadChannelNames.push(reader.string());
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 138) {
+                        break;
+                    }
+                    message.waitForLoadChannelMapInstances.push(reader.string());
+                    continue;
+                }
+                case 18: {
+                    if (tag !== 146) {
+                        break;
+                    }
+                    message.executeLoadAttributeMapInstances.push(reader.string());
+                    continue;
+                }
+                case 19: {
+                    if (tag !== 154) {
+                        break;
+                    }
+                    message.executeLoadChannelNames.push(reader.string());
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.executeLoadChannelMapInstances.push(reader.string());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1232,6 +1298,180 @@ export const StepOptions = {
         message.waitForLockAttributeKeys = object.waitForLockAttributeKeys?.map((e) => e) || [];
         message.executeLockAttributeKeys = object.executeLockAttributeKeys?.map((e) => e) || [];
         message.heartbeatTimeoutSeconds = object.heartbeatTimeoutSeconds ?? 0;
+        message.waitForLoadAttributeMapInstances = object.waitForLoadAttributeMapInstances?.map((e) => e) || [];
+        message.waitForLoadChannelNames = object.waitForLoadChannelNames?.map((e) => e) || [];
+        message.waitForLoadChannelMapInstances = object.waitForLoadChannelMapInstances?.map((e) => e) || [];
+        message.executeLoadAttributeMapInstances = object.executeLoadAttributeMapInstances?.map((e) => e) || [];
+        message.executeLoadChannelNames = object.executeLoadChannelNames?.map((e) => e) || [];
+        message.executeLoadChannelMapInstances = object.executeLoadChannelMapInstances?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseFlowTimeoutHandlerOptions() {
+    return {
+        methodTimeoutSeconds: 0,
+        heartbeatTimeoutSeconds: 0,
+        retryPolicy: undefined,
+        failurePolicy: 0,
+        failureProceedStepType: "",
+        failureProceedStepOptions: undefined,
+        durabilityOverride: 0,
+        lockAttributeKeys: [],
+        loadAttributeMapInstances: [],
+        loadChannelNames: [],
+        loadChannelMapInstances: [],
+    };
+}
+export const FlowTimeoutHandlerOptions = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.methodTimeoutSeconds !== 0) {
+            writer.uint32(8).int32(message.methodTimeoutSeconds);
+        }
+        if (message.heartbeatTimeoutSeconds !== 0) {
+            writer.uint32(16).int32(message.heartbeatTimeoutSeconds);
+        }
+        if (message.retryPolicy !== undefined) {
+            RetryPolicy.encode(message.retryPolicy, writer.uint32(26).fork()).join();
+        }
+        if (message.failurePolicy !== 0) {
+            writer.uint32(32).int32(message.failurePolicy);
+        }
+        if (message.failureProceedStepType !== "") {
+            writer.uint32(42).string(message.failureProceedStepType);
+        }
+        if (message.failureProceedStepOptions !== undefined) {
+            StepOptions.encode(message.failureProceedStepOptions, writer.uint32(50).fork()).join();
+        }
+        if (message.durabilityOverride !== 0) {
+            writer.uint32(56).int32(message.durabilityOverride);
+        }
+        for (const v of message.lockAttributeKeys) {
+            writer.uint32(66).string(v);
+        }
+        for (const v of message.loadAttributeMapInstances) {
+            writer.uint32(74).string(v);
+        }
+        for (const v of message.loadChannelNames) {
+            writer.uint32(82).string(v);
+        }
+        for (const v of message.loadChannelMapInstances) {
+            writer.uint32(90).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFlowTimeoutHandlerOptions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.methodTimeoutSeconds = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.heartbeatTimeoutSeconds = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.retryPolicy = RetryPolicy.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.failurePolicy = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.failureProceedStepType = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.failureProceedStepOptions = StepOptions.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.durabilityOverride = reader.int32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.lockAttributeKeys.push(reader.string());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.loadAttributeMapInstances.push(reader.string());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.loadChannelNames.push(reader.string());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.loadChannelMapInstances.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return FlowTimeoutHandlerOptions.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFlowTimeoutHandlerOptions();
+        message.methodTimeoutSeconds = object.methodTimeoutSeconds ?? 0;
+        message.heartbeatTimeoutSeconds = object.heartbeatTimeoutSeconds ?? 0;
+        message.retryPolicy = (object.retryPolicy !== undefined && object.retryPolicy !== null)
+            ? RetryPolicy.fromPartial(object.retryPolicy)
+            : undefined;
+        message.failurePolicy = object.failurePolicy ?? 0;
+        message.failureProceedStepType = object.failureProceedStepType ?? "";
+        message.failureProceedStepOptions =
+            (object.failureProceedStepOptions !== undefined && object.failureProceedStepOptions !== null)
+                ? StepOptions.fromPartial(object.failureProceedStepOptions)
+                : undefined;
+        message.durabilityOverride = object.durabilityOverride ?? 0;
+        message.lockAttributeKeys = object.lockAttributeKeys?.map((e) => e) || [];
+        message.loadAttributeMapInstances = object.loadAttributeMapInstances?.map((e) => e) || [];
+        message.loadChannelNames = object.loadChannelNames?.map((e) => e) || [];
+        message.loadChannelMapInstances = object.loadChannelMapInstances?.map((e) => e) || [];
         return message;
     },
 };
@@ -1284,6 +1524,7 @@ function createBaseFlowStartOptions() {
         attributes: [],
         flowConfigOverride: undefined,
         flowAlreadyStartedOptions: undefined,
+        timeoutHandlerOptions: undefined,
     };
 }
 export const FlowStartOptions = {
@@ -1306,6 +1547,9 @@ export const FlowStartOptions = {
         if (message.flowAlreadyStartedOptions !== undefined) {
             FlowAlreadyStartedOptions.encode(message.flowAlreadyStartedOptions, writer.uint32(50).fork()).join();
         }
+        if (message.timeoutHandlerOptions !== undefined) {
+            FlowTimeoutHandlerOptions.encode(message.timeoutHandlerOptions, writer.uint32(58).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -1357,6 +1601,13 @@ export const FlowStartOptions = {
                     message.flowAlreadyStartedOptions = FlowAlreadyStartedOptions.decode(reader, reader.uint32());
                     continue;
                 }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.timeoutHandlerOptions = FlowTimeoutHandlerOptions.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1383,6 +1634,10 @@ export const FlowStartOptions = {
             (object.flowAlreadyStartedOptions !== undefined && object.flowAlreadyStartedOptions !== null)
                 ? FlowAlreadyStartedOptions.fromPartial(object.flowAlreadyStartedOptions)
                 : undefined;
+        message.timeoutHandlerOptions =
+            (object.timeoutHandlerOptions !== undefined && object.timeoutHandlerOptions !== null)
+                ? FlowTimeoutHandlerOptions.fromPartial(object.timeoutHandlerOptions)
+                : undefined;
         return message;
     },
 };
@@ -4318,6 +4573,7 @@ function createBaseFlowStartedOrContinuedHistoryEvent() {
         flowConfig: undefined,
         flowTimeout: undefined,
         flowTimeoutPolicy: 0,
+        timeoutHandlerOptions: undefined,
         startOrContinue: undefined,
     };
 }
@@ -4338,6 +4594,9 @@ export const FlowStartedOrContinuedHistoryEvent = {
         if (message.flowTimeoutPolicy !== 0) {
             writer.uint32(40).int32(message.flowTimeoutPolicy);
         }
+        if (message.timeoutHandlerOptions !== undefined) {
+            FlowTimeoutHandlerOptions.encode(message.timeoutHandlerOptions, writer.uint32(50).fork()).join();
+        }
         switch (message.startOrContinue?.$case) {
             case "initialStart":
                 FlowInitialStart.encode(message.startOrContinue.value, writer.uint32(82).fork()).join();
@@ -4390,6 +4649,13 @@ export const FlowStartedOrContinuedHistoryEvent = {
                     message.flowTimeoutPolicy = reader.int32();
                     continue;
                 }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.timeoutHandlerOptions = FlowTimeoutHandlerOptions.decode(reader, reader.uint32());
+                    continue;
+                }
                 case 10: {
                     if (tag !== 82) {
                         break;
@@ -4431,6 +4697,10 @@ export const FlowStartedOrContinuedHistoryEvent = {
             ? Duration.fromPartial(object.flowTimeout)
             : undefined;
         message.flowTimeoutPolicy = object.flowTimeoutPolicy ?? 0;
+        message.timeoutHandlerOptions =
+            (object.timeoutHandlerOptions !== undefined && object.timeoutHandlerOptions !== null)
+                ? FlowTimeoutHandlerOptions.fromPartial(object.timeoutHandlerOptions)
+                : undefined;
         switch (object.startOrContinue?.$case) {
             case "initialStart": {
                 if (object.startOrContinue?.value !== undefined && object.startOrContinue?.value !== null) {
@@ -5228,6 +5498,7 @@ function createBaseStepWaitForCompletedOutput() {
         publishToChannel: [],
         recordEvents: [],
         upsertStepExecutionLocals: [],
+        deleteFromChannel: [],
     };
 }
 export const StepWaitForCompletedOutput = {
@@ -5247,6 +5518,9 @@ export const StepWaitForCompletedOutput = {
         for (const v of message.upsertStepExecutionLocals) {
             KV.encode(v, writer.uint32(42).fork()).join();
         }
+        for (const v of message.deleteFromChannel) {
+            ChannelMessageDeletion.encode(v, writer.uint32(50).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -5291,6 +5565,13 @@ export const StepWaitForCompletedOutput = {
                     message.upsertStepExecutionLocals.push(KV.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.deleteFromChannel.push(ChannelMessageDeletion.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -5311,6 +5592,7 @@ export const StepWaitForCompletedOutput = {
         message.publishToChannel = object.publishToChannel?.map((e) => ChannelMessage.fromPartial(e)) || [];
         message.recordEvents = object.recordEvents?.map((e) => KV.fromPartial(e)) || [];
         message.upsertStepExecutionLocals = object.upsertStepExecutionLocals?.map((e) => KV.fromPartial(e)) || [];
+        message.deleteFromChannel = object.deleteFromChannel?.map((e) => ChannelMessageDeletion.fromPartial(e)) || [];
         return message;
     },
 };
@@ -5321,6 +5603,7 @@ function createBaseStepExecuteCompletedOutput() {
         publishToChannel: [],
         recordEvents: [],
         upsertStepExecutionLocals: [],
+        deleteFromChannel: [],
     };
 }
 export const StepExecuteCompletedOutput = {
@@ -5340,6 +5623,9 @@ export const StepExecuteCompletedOutput = {
         for (const v of message.upsertStepExecutionLocals) {
             KV.encode(v, writer.uint32(42).fork()).join();
         }
+        for (const v of message.deleteFromChannel) {
+            ChannelMessageDeletion.encode(v, writer.uint32(50).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -5384,6 +5670,13 @@ export const StepExecuteCompletedOutput = {
                     message.upsertStepExecutionLocals.push(KV.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.deleteFromChannel.push(ChannelMessageDeletion.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -5404,6 +5697,7 @@ export const StepExecuteCompletedOutput = {
         message.publishToChannel = object.publishToChannel?.map((e) => ChannelMessage.fromPartial(e)) || [];
         message.recordEvents = object.recordEvents?.map((e) => KV.fromPartial(e)) || [];
         message.upsertStepExecutionLocals = object.upsertStepExecutionLocals?.map((e) => KV.fromPartial(e)) || [];
+        message.deleteFromChannel = object.deleteFromChannel?.map((e) => ChannelMessageDeletion.fromPartial(e)) || [];
         return message;
     },
 };
@@ -7837,7 +8131,18 @@ export const ChannelInfo = {
     },
 };
 function createBaseInvokeWaitForMethodRequest() {
-    return { context: undefined, flowType: "", stepType: "", stepInput: undefined, attributes: [] };
+    return {
+        context: undefined,
+        flowType: "",
+        stepType: "",
+        stepInput: undefined,
+        attributes: [],
+        channelInfos: {},
+        loadedChannelMessages: {},
+        loadedAttributeMapInstances: [],
+        loadedChannelNames: [],
+        loadedChannelMapInstances: [],
+    };
 }
 export const InvokeWaitForMethodRequest = {
     encode(message, writer = new BinaryWriter()) {
@@ -7856,6 +8161,22 @@ export const InvokeWaitForMethodRequest = {
         for (const v of message.attributes) {
             KV.encode(v, writer.uint32(42).fork()).join();
         }
+        globalThis.Object.entries(message.channelInfos).forEach(([key, value]) => {
+            InvokeWaitForMethodRequest_ChannelInfosEntry.encode({ key: key, value }, writer.uint32(50).fork()).join();
+        });
+        globalThis.Object.entries(message.loadedChannelMessages).forEach(([key, value]) => {
+            InvokeWaitForMethodRequest_LoadedChannelMessagesEntry.encode({ key: key, value }, writer.uint32(58).fork())
+                .join();
+        });
+        for (const v of message.loadedAttributeMapInstances) {
+            writer.uint32(66).string(v);
+        }
+        for (const v of message.loadedChannelNames) {
+            writer.uint32(74).string(v);
+        }
+        for (const v of message.loadedChannelMapInstances) {
+            writer.uint32(82).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -7900,32 +8221,197 @@ export const InvokeWaitForMethodRequest = {
                     message.attributes.push(KV.decode(reader, reader.uint32()));
                     continue;
                 }
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skip(tag & 7);
-        }
-        return message;
-    },
-    create(base) {
-        return InvokeWaitForMethodRequest.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBaseInvokeWaitForMethodRequest();
-        message.context = (object.context !== undefined && object.context !== null)
-            ? Context.fromPartial(object.context)
-            : undefined;
-        message.flowType = object.flowType ?? "";
-        message.stepType = object.stepType ?? "";
-        message.stepInput = (object.stepInput !== undefined && object.stepInput !== null)
-            ? Value.fromPartial(object.stepInput)
-            : undefined;
-        message.attributes = object.attributes?.map((e) => KV.fromPartial(e)) || [];
-        return message;
-    },
-};
-function createBaseInvokeWaitForMethodResponse() {
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    const entry6 = InvokeWaitForMethodRequest_ChannelInfosEntry.decode(reader, reader.uint32());
+                    if (entry6.value !== undefined) {
+                        message.channelInfos[entry6.key] = entry6.value;
+                    }
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    const entry7 = InvokeWaitForMethodRequest_LoadedChannelMessagesEntry.decode(reader, reader.uint32());
+                    if (entry7.value !== undefined) {
+                        message.loadedChannelMessages[entry7.key] = entry7.value;
+                    }
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.loadedAttributeMapInstances.push(reader.string());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.loadedChannelNames.push(reader.string());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.loadedChannelMapInstances.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeWaitForMethodRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeWaitForMethodRequest();
+        message.context = (object.context !== undefined && object.context !== null)
+            ? Context.fromPartial(object.context)
+            : undefined;
+        message.flowType = object.flowType ?? "";
+        message.stepType = object.stepType ?? "";
+        message.stepInput = (object.stepInput !== undefined && object.stepInput !== null)
+            ? Value.fromPartial(object.stepInput)
+            : undefined;
+        message.attributes = object.attributes?.map((e) => KV.fromPartial(e)) || [];
+        message.channelInfos = globalThis.Object.entries(object.channelInfos ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = ChannelInfo.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.loadedChannelMessages =
+            globalThis.Object.entries(object.loadedChannelMessages ?? {}).reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = ChannelValues.fromPartial(value);
+                }
+                return acc;
+            }, {});
+        message.loadedAttributeMapInstances = object.loadedAttributeMapInstances?.map((e) => e) || [];
+        message.loadedChannelNames = object.loadedChannelNames?.map((e) => e) || [];
+        message.loadedChannelMapInstances = object.loadedChannelMapInstances?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseInvokeWaitForMethodRequest_ChannelInfosEntry() {
+    return { key: "", value: undefined };
+}
+export const InvokeWaitForMethodRequest_ChannelInfosEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            ChannelInfo.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeWaitForMethodRequest_ChannelInfosEntry();
+        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 = ChannelInfo.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeWaitForMethodRequest_ChannelInfosEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeWaitForMethodRequest_ChannelInfosEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? ChannelInfo.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseInvokeWaitForMethodRequest_LoadedChannelMessagesEntry() {
+    return { key: "", value: undefined };
+}
+export const InvokeWaitForMethodRequest_LoadedChannelMessagesEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            ChannelValues.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeWaitForMethodRequest_LoadedChannelMessagesEntry();
+        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 = ChannelValues.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeWaitForMethodRequest_LoadedChannelMessagesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeWaitForMethodRequest_LoadedChannelMessagesEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? ChannelValues.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseInvokeWaitForMethodResponse() {
     return {
         localActivityMetadata: undefined,
         upsertAttributes: [],
@@ -7933,6 +8419,7 @@ function createBaseInvokeWaitForMethodResponse() {
         upsertStepExeLocals: [],
         recordEvents: [],
         publishToChannel: [],
+        deleteFromChannel: [],
     };
 }
 export const InvokeWaitForMethodResponse = {
@@ -7955,6 +8442,9 @@ export const InvokeWaitForMethodResponse = {
         for (const v of message.publishToChannel) {
             ChannelMessage.encode(v, writer.uint32(50).fork()).join();
         }
+        for (const v of message.deleteFromChannel) {
+            ChannelMessageDeletion.encode(v, writer.uint32(58).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -8006,6 +8496,13 @@ export const InvokeWaitForMethodResponse = {
                     message.publishToChannel.push(ChannelMessage.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.deleteFromChannel.push(ChannelMessageDeletion.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -8030,6 +8527,7 @@ export const InvokeWaitForMethodResponse = {
         message.upsertStepExeLocals = object.upsertStepExeLocals?.map((e) => KV.fromPartial(e)) || [];
         message.recordEvents = object.recordEvents?.map((e) => KV.fromPartial(e)) || [];
         message.publishToChannel = object.publishToChannel?.map((e) => ChannelMessage.fromPartial(e)) || [];
+        message.deleteFromChannel = object.deleteFromChannel?.map((e) => ChannelMessageDeletion.fromPartial(e)) || [];
         return message;
     },
 };
@@ -8233,6 +8731,11 @@ function createBaseInvokeExecuteMethodRequest() {
         attributes: [],
         stepExeLocals: [],
         conditionResults: undefined,
+        channelInfos: {},
+        loadedChannelMessages: {},
+        loadedAttributeMapInstances: [],
+        loadedChannelNames: [],
+        loadedChannelMapInstances: [],
     };
 }
 export const InvokeExecuteMethodRequest = {
@@ -8258,6 +8761,22 @@ export const InvokeExecuteMethodRequest = {
         if (message.conditionResults !== undefined) {
             ConditionResults.encode(message.conditionResults, writer.uint32(58).fork()).join();
         }
+        globalThis.Object.entries(message.channelInfos).forEach(([key, value]) => {
+            InvokeExecuteMethodRequest_ChannelInfosEntry.encode({ key: key, value }, writer.uint32(66).fork()).join();
+        });
+        globalThis.Object.entries(message.loadedChannelMessages).forEach(([key, value]) => {
+            InvokeExecuteMethodRequest_LoadedChannelMessagesEntry.encode({ key: key, value }, writer.uint32(74).fork())
+                .join();
+        });
+        for (const v of message.loadedAttributeMapInstances) {
+            writer.uint32(82).string(v);
+        }
+        for (const v of message.loadedChannelNames) {
+            writer.uint32(90).string(v);
+        }
+        for (const v of message.loadedChannelMapInstances) {
+            writer.uint32(98).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -8316,6 +8835,47 @@ export const InvokeExecuteMethodRequest = {
                     message.conditionResults = ConditionResults.decode(reader, reader.uint32());
                     continue;
                 }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    const entry8 = InvokeExecuteMethodRequest_ChannelInfosEntry.decode(reader, reader.uint32());
+                    if (entry8.value !== undefined) {
+                        message.channelInfos[entry8.key] = entry8.value;
+                    }
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    const entry9 = InvokeExecuteMethodRequest_LoadedChannelMessagesEntry.decode(reader, reader.uint32());
+                    if (entry9.value !== undefined) {
+                        message.loadedChannelMessages[entry9.key] = entry9.value;
+                    }
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.loadedAttributeMapInstances.push(reader.string());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.loadedChannelNames.push(reader.string());
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.loadedChannelMapInstances.push(reader.string());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -8342,6 +8902,130 @@ export const InvokeExecuteMethodRequest = {
         message.conditionResults = (object.conditionResults !== undefined && object.conditionResults !== null)
             ? ConditionResults.fromPartial(object.conditionResults)
             : undefined;
+        message.channelInfos = globalThis.Object.entries(object.channelInfos ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = ChannelInfo.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.loadedChannelMessages =
+            globalThis.Object.entries(object.loadedChannelMessages ?? {}).reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = ChannelValues.fromPartial(value);
+                }
+                return acc;
+            }, {});
+        message.loadedAttributeMapInstances = object.loadedAttributeMapInstances?.map((e) => e) || [];
+        message.loadedChannelNames = object.loadedChannelNames?.map((e) => e) || [];
+        message.loadedChannelMapInstances = object.loadedChannelMapInstances?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseInvokeExecuteMethodRequest_ChannelInfosEntry() {
+    return { key: "", value: undefined };
+}
+export const InvokeExecuteMethodRequest_ChannelInfosEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            ChannelInfo.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeExecuteMethodRequest_ChannelInfosEntry();
+        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 = ChannelInfo.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeExecuteMethodRequest_ChannelInfosEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeExecuteMethodRequest_ChannelInfosEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? ChannelInfo.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseInvokeExecuteMethodRequest_LoadedChannelMessagesEntry() {
+    return { key: "", value: undefined };
+}
+export const InvokeExecuteMethodRequest_LoadedChannelMessagesEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            ChannelValues.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInvokeExecuteMethodRequest_LoadedChannelMessagesEntry();
+        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 = ChannelValues.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return InvokeExecuteMethodRequest_LoadedChannelMessagesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInvokeExecuteMethodRequest_LoadedChannelMessagesEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? ChannelValues.fromPartial(object.value)
+            : undefined;
         return message;
     },
 };
@@ -8353,6 +9037,7 @@ function createBaseInvokeExecuteMethodResponse() {
         recordEvents: [],
         upsertStepExeLocals: [],
         publishToChannel: [],
+        deleteFromChannel: [],
     };
 }
 export const InvokeExecuteMethodResponse = {
@@ -8375,6 +9060,9 @@ export const InvokeExecuteMethodResponse = {
         for (const v of message.publishToChannel) {
             ChannelMessage.encode(v, writer.uint32(50).fork()).join();
         }
+        for (const v of message.deleteFromChannel) {
+            ChannelMessageDeletion.encode(v, writer.uint32(58).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -8426,6 +9114,13 @@ export const InvokeExecuteMethodResponse = {
                     message.publishToChannel.push(ChannelMessage.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.deleteFromChannel.push(ChannelMessageDeletion.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -8450,6 +9145,7 @@ export const InvokeExecuteMethodResponse = {
         message.recordEvents = object.recordEvents?.map((e) => KV.fromPartial(e)) || [];
         message.upsertStepExeLocals = object.upsertStepExeLocals?.map((e) => KV.fromPartial(e)) || [];
         message.publishToChannel = object.publishToChannel?.map((e) => ChannelMessage.fromPartial(e)) || [];
+        message.deleteFromChannel = object.deleteFromChannel?.map((e) => ChannelMessageDeletion.fromPartial(e)) || [];
         return message;
     },
 };
@@ -9392,6 +10088,7 @@ function createBaseSubFlowOptions() {
         attributes: [],
         flowConfigOverride: undefined,
         flowTimeoutPolicy: 0,
+        timeoutHandlerOptions: undefined,
     };
 }
 export const SubFlowOptions = {
@@ -9417,6 +10114,9 @@ export const SubFlowOptions = {
         if (message.flowTimeoutPolicy !== 0) {
             writer.uint32(56).int32(message.flowTimeoutPolicy);
         }
+        if (message.timeoutHandlerOptions !== undefined) {
+            FlowTimeoutHandlerOptions.encode(message.timeoutHandlerOptions, writer.uint32(66).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -9475,6 +10175,13 @@ export const SubFlowOptions = {
                     message.flowTimeoutPolicy = reader.int32();
                     continue;
                 }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.timeoutHandlerOptions = FlowTimeoutHandlerOptions.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -9499,6 +10206,10 @@ export const SubFlowOptions = {
             ? FlowConfig.fromPartial(object.flowConfigOverride)
             : undefined;
         message.flowTimeoutPolicy = object.flowTimeoutPolicy ?? 0;
+        message.timeoutHandlerOptions =
+            (object.timeoutHandlerOptions !== undefined && object.timeoutHandlerOptions !== null)
+                ? FlowTimeoutHandlerOptions.fromPartial(object.timeoutHandlerOptions)
+                : undefined;
         return message;
     },
 };
@@ -11049,6 +11760,7 @@ function createBaseInterpreterWorkflowInput() {
         config: undefined,
         isResumeFromContinueAsNew: false,
         continueAsNewInput: undefined,
+        timeoutHandlerOptions: undefined,
     };
 }
 export const InterpreterWorkflowInput = {
@@ -11083,6 +11795,9 @@ export const InterpreterWorkflowInput = {
         if (message.continueAsNewInput !== undefined) {
             ContinueAsNewInput.encode(message.continueAsNewInput, writer.uint32(82).fork()).join();
         }
+        if (message.timeoutHandlerOptions !== undefined) {
+            FlowTimeoutHandlerOptions.encode(message.timeoutHandlerOptions, writer.uint32(90).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -11162,6 +11877,13 @@ export const InterpreterWorkflowInput = {
                     message.continueAsNewInput = ContinueAsNewInput.decode(reader, reader.uint32());
                     continue;
                 }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.timeoutHandlerOptions = FlowTimeoutHandlerOptions.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -11193,6 +11915,10 @@ export const InterpreterWorkflowInput = {
         message.continueAsNewInput = (object.continueAsNewInput !== undefined && object.continueAsNewInput !== null)
             ? ContinueAsNewInput.fromPartial(object.continueAsNewInput)
             : undefined;
+        message.timeoutHandlerOptions =
+            (object.timeoutHandlerOptions !== undefined && object.timeoutHandlerOptions !== null)
+                ? FlowTimeoutHandlerOptions.fromPartial(object.timeoutHandlerOptions)
+                : undefined;
         return message;
     },
 };