TestIsExcludedAPI_UnknownMethod

220 func (*StartWorkflowExecutionRequest) ProtoMessage() {}

221

222 > func (x *StartWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

223 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[1]

224 > if x != nil {

225 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

226 if ms.LoadMessageInfo() == nil {

229 return ms

230 }

231 > return mi.MessageOf(x) request_response.pb.go

232 }

233

393 func (*StartWorkflowExecutionResponse) ProtoMessage() {}

394

395 > func (x *StartWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

396 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[2]

397 > if x != nil {

398 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

399 if ms.LoadMessageInfo() == nil {

402 return ms

403 }

404 > return mi.MessageOf(x) request_response.pb.go

405 }

406

484 func (*GetMutableStateRequest) ProtoMessage() {}

485

486 > func (x *GetMutableStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

487 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[3]

488 > if x != nil {

489 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

490 if ms.LoadMessageInfo() == nil {

493 return ms

494 }

495 > return mi.MessageOf(x) request_response.pb.go

496 }

497

592 func (*GetMutableStateResponse) ProtoMessage() {}

593

594 > func (x *GetMutableStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

595 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[4]

596 > if x != nil {

597 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

598 if ms.LoadMessageInfo() == nil {

601 return ms

602 }

603 > return mi.MessageOf(x) request_response.pb.go

604 }

605

780 func (*PollMutableStateRequest) ProtoMessage() {}

781

782 > func (x *PollMutableStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

783 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[5]

784 > if x != nil {

785 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

786 if ms.LoadMessageInfo() == nil {

789 return ms

790 }

791 > return mi.MessageOf(x) request_response.pb.go

792 }

793

868 func (*PollMutableStateResponse) ProtoMessage() {}

869

870 > func (x *PollMutableStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

871 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[6]

872 > if x != nil {

873 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

874 if ms.LoadMessageInfo() == nil {

877 return ms

878 }

879 > return mi.MessageOf(x) request_response.pb.go

880 }

881

1004 func (*ResetStickyTaskQueueRequest) ProtoMessage() {}

1005

1006 > func (x *ResetStickyTaskQueueRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

1007 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[7]

1008 > if x != nil {

1009 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1010 if ms.LoadMessageInfo() == nil {

1013 return ms

1014 }

1015 > return mi.MessageOf(x) request_response.pb.go

1016 }

1017

1054 func (*ResetStickyTaskQueueResponse) ProtoMessage() {}

1055

1056 > func (x *ResetStickyTaskQueueResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

1057 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[8]

1058 > if x != nil {

1059 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1060 if ms.LoadMessageInfo() == nil {

1063 return ms

1064 }

1065 > return mi.MessageOf(x) request_response.pb.go

1066 }

1067

1093 func (*ExecuteMultiOperationRequest) ProtoMessage() {}

1094

1095 > func (x *ExecuteMultiOperationRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

1096 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[9]

1097 > if x != nil {

1098 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1099 if ms.LoadMessageInfo() == nil {

1102 return ms

1103 }

1104 > return mi.MessageOf(x) request_response.pb.go

1105 }

1106

1151 func (*ExecuteMultiOperationResponse) ProtoMessage() {}

1152

1153 > func (x *ExecuteMultiOperationResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

1154 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[10]

1155 > if x != nil {

1156 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1157 if ms.LoadMessageInfo() == nil {

1160 return ms

1161 }

1162 > return mi.MessageOf(x) request_response.pb.go

1163 }

1164

1216 func (*RecordWorkflowTaskStartedRequest) ProtoMessage() {}

1217

1218 > func (x *RecordWorkflowTaskStartedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

1219 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[11]

1220 > if x != nil {

1221 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1222 if ms.LoadMessageInfo() == nil {

1225 return ms

1226 }

1227 > return mi.MessageOf(x) request_response.pb.go

1228 }

1229

1371 func (*RecordWorkflowTaskStartedResponse) ProtoMessage() {}

1372

1373 > func (x *RecordWorkflowTaskStartedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

1374 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[12]

1375 > if x != nil {

1376 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1377 if ms.LoadMessageInfo() == nil {

1380 return ms

1381 }

1382 > return mi.MessageOf(x) request_response.pb.go

1383 }

1384

1789 func (*RecordActivityTaskStartedRequest) ProtoMessage() {}

1790

1791 > func (x *RecordActivityTaskStartedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

1792 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[14]

1793 > if x != nil {

1794 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1795 if ms.LoadMessageInfo() == nil {

1798 return ms

1799 }

1800 > return mi.MessageOf(x) request_response.pb.go

1801 }

1802

1923 func (*RecordActivityTaskStartedResponse) ProtoMessage() {}

1924

1925 > func (x *RecordActivityTaskStartedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

1926 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[15]

1927 > if x != nil {

1928 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

1929 if ms.LoadMessageInfo() == nil {

1932 return ms

1933 }

1934 > return mi.MessageOf(x) request_response.pb.go

1935 }

1936

2052 func (*RespondWorkflowTaskCompletedRequest) ProtoMessage() {}

2053

2054 > func (x *RespondWorkflowTaskCompletedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2055 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[16]

2056 > if x != nil {

2057 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2058 if ms.LoadMessageInfo() == nil {

2061 return ms

2062 }

2063 > return mi.MessageOf(x) request_response.pb.go

2064 }

2065

2107 func (*RespondWorkflowTaskCompletedResponse) ProtoMessage() {}

2108

2109 > func (x *RespondWorkflowTaskCompletedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2110 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[17]

2111 > if x != nil {

2112 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2113 if ms.LoadMessageInfo() == nil {

2116 return ms

2117 }

2118 > return mi.MessageOf(x) request_response.pb.go

2119 }

2120

2174 func (*RespondWorkflowTaskFailedRequest) ProtoMessage() {}

2175

2176 > func (x *RespondWorkflowTaskFailedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2177 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[18]

2178 > if x != nil {

2179 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2180 if ms.LoadMessageInfo() == nil {

2183 return ms

2184 }

2185 > return mi.MessageOf(x) request_response.pb.go

2186 }

2187

2224 func (*RespondWorkflowTaskFailedResponse) ProtoMessage() {}

2225

2226 > func (x *RespondWorkflowTaskFailedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2227 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[19]

2228 > if x != nil {

2229 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2230 if ms.LoadMessageInfo() == nil {

2233 return ms

2234 }

2235 > return mi.MessageOf(x) request_response.pb.go

2236 }

2237

2265 func (*IsWorkflowTaskValidRequest) ProtoMessage() {}

2266

2267 > func (x *IsWorkflowTaskValidRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2268 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[20]

2269 > if x != nil {

2270 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2271 if ms.LoadMessageInfo() == nil {

2274 return ms

2275 }

2276 > return mi.MessageOf(x) request_response.pb.go

2277 }

2278

2338 func (*IsWorkflowTaskValidResponse) ProtoMessage() {}

2339

2340 > func (x *IsWorkflowTaskValidResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2341 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[21]

2342 > if x != nil {

2343 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2344 if ms.LoadMessageInfo() == nil {

2347 return ms

2348 }

2349 > return mi.MessageOf(x) request_response.pb.go

2350 }

2351

2383 func (*RecordActivityTaskHeartbeatRequest) ProtoMessage() {}

2384

2385 > func (x *RecordActivityTaskHeartbeatRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2386 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[22]

2387 > if x != nil {

2388 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2389 if ms.LoadMessageInfo() == nil {

2392 return ms

2393 }

2394 > return mi.MessageOf(x) request_response.pb.go

2395 }

2396

2436 func (*RecordActivityTaskHeartbeatResponse) ProtoMessage() {}

2437

2438 > func (x *RecordActivityTaskHeartbeatResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2439 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[23]

2440 > if x != nil {

2441 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2442 if ms.LoadMessageInfo() == nil {

2445 return ms

2446 }

2447 > return mi.MessageOf(x) request_response.pb.go

2448 }

2449

2495 func (*RespondActivityTaskCompletedRequest) ProtoMessage() {}

2496

2497 > func (x *RespondActivityTaskCompletedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2498 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[24]

2499 > if x != nil {

2500 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2501 if ms.LoadMessageInfo() == nil {

2504 return ms

2505 }

2506 > return mi.MessageOf(x) request_response.pb.go

2507 }

2508

2545 func (*RespondActivityTaskCompletedResponse) ProtoMessage() {}

2546

2547 > func (x *RespondActivityTaskCompletedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2548 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[25]

2549 > if x != nil {

2550 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2551 if ms.LoadMessageInfo() == nil {

2554 return ms

2555 }

2556 > return mi.MessageOf(x) request_response.pb.go

2557 }

2558

2583 func (*RespondActivityTaskFailedRequest) ProtoMessage() {}

2584

2585 > func (x *RespondActivityTaskFailedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2586 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[26]

2587 > if x != nil {

2588 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2589 if ms.LoadMessageInfo() == nil {

2592 return ms

2593 }

2594 > return mi.MessageOf(x) request_response.pb.go

2595 }

2596

2633 func (*RespondActivityTaskFailedResponse) ProtoMessage() {}

2634

2635 > func (x *RespondActivityTaskFailedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2636 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[27]

2637 > if x != nil {

2638 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2639 if ms.LoadMessageInfo() == nil {

2642 return ms

2643 }

2644 > return mi.MessageOf(x) request_response.pb.go

2645 }

2646

2671 func (*RespondActivityTaskCanceledRequest) ProtoMessage() {}

2672

2673 > func (x *RespondActivityTaskCanceledRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2674 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[28]

2675 > if x != nil {

2676 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2677 if ms.LoadMessageInfo() == nil {

2680 return ms

2681 }

2682 > return mi.MessageOf(x) request_response.pb.go

2683 }

2684

2721 func (*RespondActivityTaskCanceledResponse) ProtoMessage() {}

2722

2723 > func (x *RespondActivityTaskCanceledResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2724 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[29]

2725 > if x != nil {

2726 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2727 if ms.LoadMessageInfo() == nil {

2730 return ms

2731 }

2732 > return mi.MessageOf(x) request_response.pb.go

2733 }

2734

2763 func (*IsActivityTaskValidRequest) ProtoMessage() {}

2764

2765 > func (x *IsActivityTaskValidRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2766 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[30]

2767 > if x != nil {

2768 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2769 if ms.LoadMessageInfo() == nil {

2772 return ms

2773 }

2774 > return mi.MessageOf(x) request_response.pb.go

2775 }

2776

2836 func (*IsActivityTaskValidResponse) ProtoMessage() {}

2837

2838 > func (x *IsActivityTaskValidResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2839 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[31]

2840 > if x != nil {

2841 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2842 if ms.LoadMessageInfo() == nil {

2845 return ms

2846 }

2847 > return mi.MessageOf(x) request_response.pb.go

2848 }

2849

2883 func (*SignalWorkflowExecutionRequest) ProtoMessage() {}

2884

2885 > func (x *SignalWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2886 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[32]

2887 > if x != nil {

2888 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2889 if ms.LoadMessageInfo() == nil {

2892 return ms

2893 }

2894 > return mi.MessageOf(x) request_response.pb.go

2895 }

2896

2948 func (*SignalWorkflowExecutionResponse) ProtoMessage() {}

2949

2950 > func (x *SignalWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

2951 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[33]

2952 > if x != nil {

2953 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

2954 if ms.LoadMessageInfo() == nil {

2957 return ms

2958 }

2959 > return mi.MessageOf(x) request_response.pb.go

2960 }

2961

2996 func (*SignalWithStartWorkflowExecutionRequest) ProtoMessage() {}

2997

2998 > func (x *SignalWithStartWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

2999 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[34]

3000 > if x != nil {

3001 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3002 if ms.LoadMessageInfo() == nil {

3005 return ms

3006 }

3007 > return mi.MessageOf(x) request_response.pb.go

3008 }

3009

3053 func (*SignalWithStartWorkflowExecutionResponse) ProtoMessage() {}

3054

3055 > func (x *SignalWithStartWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3056 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[35]

3057 > if x != nil {

3058 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3059 if ms.LoadMessageInfo() == nil {

3062 return ms

3063 }

3064 > return mi.MessageOf(x) request_response.pb.go

3065 }

3066

3120 func (*RemoveSignalMutableStateRequest) ProtoMessage() {}

3121

3122 > func (x *RemoveSignalMutableStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3123 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[36]

3124 > if x != nil {

3125 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3126 if ms.LoadMessageInfo() == nil {

3129 return ms

3130 }

3131 > return mi.MessageOf(x) request_response.pb.go

3132 }

3133

3177 func (*RemoveSignalMutableStateResponse) ProtoMessage() {}

3178

3179 > func (x *RemoveSignalMutableStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3180 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[37]

3181 > if x != nil {

3182 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3183 if ms.LoadMessageInfo() == nil {

3186 return ms

3187 }

3188 > return mi.MessageOf(x) request_response.pb.go

3189 }

3190

3217 func (*TerminateWorkflowExecutionRequest) ProtoMessage() {}

3218

3219 > func (x *TerminateWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3220 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[38]

3221 > if x != nil {

3222 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3223 if ms.LoadMessageInfo() == nil {

3226 return ms

3227 }

3228 > return mi.MessageOf(x) request_response.pb.go

3229 }

3230

3281 func (*TerminateWorkflowExecutionResponse) ProtoMessage() {}

3282

3283 > func (x *TerminateWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3284 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[39]

3285 > if x != nil {

3286 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3287 if ms.LoadMessageInfo() == nil {

3290 return ms

3291 }

3292 > return mi.MessageOf(x) request_response.pb.go

3293 }

3294

3320 func (*DeleteWorkflowExecutionRequest) ProtoMessage() {}

3321

3322 > func (x *DeleteWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3323 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[40]

3324 > if x != nil {

3325 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3326 if ms.LoadMessageInfo() == nil {

3329 return ms

3330 }

3331 > return mi.MessageOf(x) request_response.pb.go

3332 }

3333

3377 func (*DeleteWorkflowExecutionResponse) ProtoMessage() {}

3378

3379 > func (x *DeleteWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3380 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[41]

3381 > if x != nil {

3382 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3383 if ms.LoadMessageInfo() == nil {

3386 return ms

3387 }

3388 > return mi.MessageOf(x) request_response.pb.go

3389 }

3390

3415 func (*ResetWorkflowExecutionRequest) ProtoMessage() {}

3416

3417 > func (x *ResetWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3418 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[42]

3419 > if x != nil {

3420 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3421 if ms.LoadMessageInfo() == nil {

3424 return ms

3425 }

3426 > return mi.MessageOf(x) request_response.pb.go

3427 }

3428

3466 func (*ResetWorkflowExecutionResponse) ProtoMessage() {}

3467

3468 > func (x *ResetWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3469 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[43]

3470 > if x != nil {

3471 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3472 if ms.LoadMessageInfo() == nil {

3475 return ms

3476 }

3477 > return mi.MessageOf(x) request_response.pb.go

3478 }

3479

3514 func (*RequestCancelWorkflowExecutionRequest) ProtoMessage() {}

3515

3516 > func (x *RequestCancelWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3517 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[44]

3518 > if x != nil {

3519 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3520 if ms.LoadMessageInfo() == nil {

3523 return ms

3524 }

3525 > return mi.MessageOf(x) request_response.pb.go

3526 }

3527

3585 func (*RequestCancelWorkflowExecutionResponse) ProtoMessage() {}

3586

3587 > func (x *RequestCancelWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3588 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[45]

3589 > if x != nil {

3590 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3591 if ms.LoadMessageInfo() == nil {

3594 return ms

3595 }

3596 > return mi.MessageOf(x) request_response.pb.go

3597 }

3598

3626 func (*ScheduleWorkflowTaskRequest) ProtoMessage() {}

3627

3628 > func (x *ScheduleWorkflowTaskRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3629 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[46]

3630 > if x != nil {

3631 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3632 if ms.LoadMessageInfo() == nil {

3635 return ms

3636 }

3637 > return mi.MessageOf(x) request_response.pb.go

3638 }

3639

3697 func (*ScheduleWorkflowTaskResponse) ProtoMessage() {}

3698

3699 > func (x *ScheduleWorkflowTaskResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3700 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[47]

3701 > if x != nil {

3702 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3703 if ms.LoadMessageInfo() == nil {

3706 return ms

3707 }

3708 > return mi.MessageOf(x) request_response.pb.go

3709 }

3710

3736 func (*VerifyFirstWorkflowTaskScheduledRequest) ProtoMessage() {}

3737

3738 > func (x *VerifyFirstWorkflowTaskScheduledRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3739 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[48]

3740 > if x != nil {

3741 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3742 if ms.LoadMessageInfo() == nil {

3745 return ms

3746 }

3747 > return mi.MessageOf(x) request_response.pb.go

3748 }

3749

3793 func (*VerifyFirstWorkflowTaskScheduledResponse) ProtoMessage() {}

3794

3795 > func (x *VerifyFirstWorkflowTaskScheduledResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3796 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[49]

3797 > if x != nil {

3798 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3799 if ms.LoadMessageInfo() == nil {

3802 return ms

3803 }

3804 > return mi.MessageOf(x) request_response.pb.go

3805 }

3806

3843 func (*RecordChildExecutionCompletedRequest) ProtoMessage() {}

3844

3845 > func (x *RecordChildExecutionCompletedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3846 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[50]

3847 > if x != nil {

3848 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3849 if ms.LoadMessageInfo() == nil {

3852 return ms

3853 }

3854 > return mi.MessageOf(x) request_response.pb.go

3855 }

3856

3935 func (*RecordChildExecutionCompletedResponse) ProtoMessage() {}

3936

3937 > func (x *RecordChildExecutionCompletedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

3938 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[51]

3939 > if x != nil {

3940 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3941 if ms.LoadMessageInfo() == nil {

3944 return ms

3945 }

3946 > return mi.MessageOf(x) request_response.pb.go

3947 }

3948

3978 func (*VerifyChildExecutionCompletionRecordedRequest) ProtoMessage() {}

3979

3980 > func (x *VerifyChildExecutionCompletionRecordedRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

3981 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[52]

3982 > if x != nil {

3983 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

3984 if ms.LoadMessageInfo() == nil {

3987 return ms

3988 }

3989 > return mi.MessageOf(x) request_response.pb.go

3990 }

3991

4063 func (*VerifyChildExecutionCompletionRecordedResponse) ProtoMessage() {}

4064

4065 > func (x *VerifyChildExecutionCompletionRecordedResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

4066 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[53]

4067 > if x != nil {

4068 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4069 if ms.LoadMessageInfo() == nil {

4072 return ms

4073 }

4074 > return mi.MessageOf(x) request_response.pb.go

4075 }

4076

4101 func (*DescribeWorkflowExecutionRequest) ProtoMessage() {}

4102

4103 > func (x *DescribeWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

4104 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[54]

4105 > if x != nil {

4106 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4107 if ms.LoadMessageInfo() == nil {

4110 return ms

4111 }

4112 > return mi.MessageOf(x) request_response.pb.go

4113 }

4114

4159 func (*DescribeWorkflowExecutionResponse) ProtoMessage() {}

4160

4161 > func (x *DescribeWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

4162 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[55]

4163 > if x != nil {

4164 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4165 if ms.LoadMessageInfo() == nil {

4168 return ms

4169 }

4170 > return mi.MessageOf(x) request_response.pb.go

4171 }

4172

4259 func (*ReplicateEventsV2Request) ProtoMessage() {}

4260

4261 > func (x *ReplicateEventsV2Request) ProtoReflect() protoreflect.Message { request_response.pb.go

4262 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[56]

4263 > if x != nil {

4264 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4265 if ms.LoadMessageInfo() == nil {

4268 return ms

4269 }

4270 > return mi.MessageOf(x) request_response.pb.go

4271 }

4272

4344 func (*ReplicateEventsV2Response) ProtoMessage() {}

4345

4346 > func (x *ReplicateEventsV2Response) ProtoReflect() protoreflect.Message { request_response.pb.go

4347 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[57]

4348 > if x != nil {

4349 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4350 if ms.LoadMessageInfo() == nil {

4353 return ms

4354 }

4355 > return mi.MessageOf(x) request_response.pb.go

4356 }

4357

4385 func (*ReplicateWorkflowStateRequest) ProtoMessage() {}

4386

4387 > func (x *ReplicateWorkflowStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

4388 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[58]

4389 > if x != nil {

4390 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4391 if ms.LoadMessageInfo() == nil {

4394 return ms

4395 }

4396 > return mi.MessageOf(x) request_response.pb.go

4397 }

4398

4456 func (*ReplicateWorkflowStateResponse) ProtoMessage() {}

4457

4458 > func (x *ReplicateWorkflowStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

4459 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[59]

4460 > if x != nil {

4461 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4462 if ms.LoadMessageInfo() == nil {

4465 return ms

4466 }

4467 > return mi.MessageOf(x) request_response.pb.go

4468 }

4469

4495 func (*SyncShardStatusRequest) ProtoMessage() {}

4496

4497 > func (x *SyncShardStatusRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

4498 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[60]

4499 > if x != nil {

4500 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4501 if ms.LoadMessageInfo() == nil {

4504 return ms

4505 }

4506 > return mi.MessageOf(x) request_response.pb.go

4507 }

4508

4552 func (*SyncShardStatusResponse) ProtoMessage() {}

4553

4554 > func (x *SyncShardStatusResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

4555 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[61]

4556 > if x != nil {

4557 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4558 if ms.LoadMessageInfo() == nil {

4561 return ms

4562 }

4563 > return mi.MessageOf(x) request_response.pb.go

4564 }

4565

4621 func (*SyncActivityRequest) ProtoMessage() {}

4622

4623 > func (x *SyncActivityRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

4624 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[62]

4625 > if x != nil {

4626 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

4627 if ms.LoadMessageInfo() == nil {

4630 return ms

4631 }

4632 > return mi.MessageOf(x) request_response.pb.go

4633 }

4634

5126 func (*SyncActivityResponse) ProtoMessage() {}

5127

5128 > func (x *SyncActivityResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5129 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[65]

5130 > if x != nil {

5131 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5132 if ms.LoadMessageInfo() == nil {

5135 return ms

5136 }

5137 > return mi.MessageOf(x) request_response.pb.go

5138 }

5139

5167 func (*DescribeMutableStateRequest) ProtoMessage() {}

5168

5169 > func (x *DescribeMutableStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5170 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[66]

5171 > if x != nil {

5172 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5173 if ms.LoadMessageInfo() == nil {

5176 return ms

5177 }

5178 > return mi.MessageOf(x) request_response.pb.go

5179 }

5180

5236 func (*DescribeMutableStateResponse) ProtoMessage() {}

5237

5238 > func (x *DescribeMutableStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5239 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[67]

5240 > if x != nil {

5241 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5242 if ms.LoadMessageInfo() == nil {

5245 return ms

5246 }

5247 > return mi.MessageOf(x) request_response.pb.go

5248 }

5249

5292 func (*DescribeHistoryHostRequest) ProtoMessage() {}

5293

5294 > func (x *DescribeHistoryHostRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5295 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[68]

5296 > if x != nil {

5297 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5298 if ms.LoadMessageInfo() == nil {

5301 return ms

5302 }

5303 > return mi.MessageOf(x) request_response.pb.go

5304 }

5305

5360 func (*DescribeHistoryHostResponse) ProtoMessage() {}

5361

5362 > func (x *DescribeHistoryHostResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5363 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[69]

5364 > if x != nil {

5365 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5366 if ms.LoadMessageInfo() == nil {

5369 return ms

5370 }

5371 > return mi.MessageOf(x) request_response.pb.go

5372 }

5373

5425 func (*CloseShardRequest) ProtoMessage() {}

5426

5427 > func (x *CloseShardRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5428 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[70]

5429 > if x != nil {

5430 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5431 if ms.LoadMessageInfo() == nil {

5434 return ms

5435 }

5436 > return mi.MessageOf(x) request_response.pb.go

5437 }

5438

5468 func (*CloseShardResponse) ProtoMessage() {}

5469

5470 > func (x *CloseShardResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5471 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[71]

5472 > if x != nil {

5473 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5474 if ms.LoadMessageInfo() == nil {

5477 return ms

5478 }

5479 > return mi.MessageOf(x) request_response.pb.go

5480 }

5481

5505 func (*GetShardRequest) ProtoMessage() {}

5506

5507 > func (x *GetShardRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5508 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[72]

5509 > if x != nil {

5510 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5511 if ms.LoadMessageInfo() == nil {

5514 return ms

5515 }

5516 > return mi.MessageOf(x) request_response.pb.go

5517 }

5518

5549 func (*GetShardResponse) ProtoMessage() {}

5550

5551 > func (x *GetShardResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5552 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[73]

5553 > if x != nil {

5554 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5555 if ms.LoadMessageInfo() == nil {

5558 return ms

5559 }

5560 > return mi.MessageOf(x) request_response.pb.go

5561 }

5562

5597 func (*RemoveTaskRequest) ProtoMessage() {}

5598

5599 > func (x *RemoveTaskRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5600 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[74]

5601 > if x != nil {

5602 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5603 if ms.LoadMessageInfo() == nil {

5606 return ms

5607 }

5608 > return mi.MessageOf(x) request_response.pb.go

5609 }

5610

5661 func (*RemoveTaskResponse) ProtoMessage() {}

5662

5663 > func (x *RemoveTaskResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5664 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[75]

5665 > if x != nil {

5666 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5667 if ms.LoadMessageInfo() == nil {

5670 return ms

5671 }

5672 > return mi.MessageOf(x) request_response.pb.go

5673 }

5674

5699 func (*GetReplicationMessagesRequest) ProtoMessage() {}

5700

5701 > func (x *GetReplicationMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5702 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[76]

5703 > if x != nil {

5704 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5705 if ms.LoadMessageInfo() == nil {

5708 return ms

5709 }

5710 > return mi.MessageOf(x) request_response.pb.go

5711 }

5712

5750 func (*GetReplicationMessagesResponse) ProtoMessage() {}

5751

5752 > func (x *GetReplicationMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5753 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[77]

5754 > if x != nil {

5755 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5756 if ms.LoadMessageInfo() == nil {

5759 return ms

5760 }

5761 > return mi.MessageOf(x) request_response.pb.go

5762 }

5763

5794 func (*GetDLQReplicationMessagesRequest) ProtoMessage() {}

5795

5796 > func (x *GetDLQReplicationMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5797 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[78]

5798 > if x != nil {

5799 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5800 if ms.LoadMessageInfo() == nil {

5803 return ms

5804 }

5805 > return mi.MessageOf(x) request_response.pb.go

5806 }

5807

5838 func (*GetDLQReplicationMessagesResponse) ProtoMessage() {}

5839

5840 > func (x *GetDLQReplicationMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5841 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[79]

5842 > if x != nil {

5843 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5844 if ms.LoadMessageInfo() == nil {

5847 return ms

5848 }

5849 > return mi.MessageOf(x) request_response.pb.go

5850 }

5851

5883 func (*QueryWorkflowRequest) ProtoMessage() {}

5884

5885 > func (x *QueryWorkflowRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5886 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[80]

5887 > if x != nil {

5888 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5889 if ms.LoadMessageInfo() == nil {

5892 return ms

5893 }

5894 > return mi.MessageOf(x) request_response.pb.go

5895 }

5896

5934 func (*QueryWorkflowResponse) ProtoMessage() {}

5935

5936 > func (x *QueryWorkflowResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

5937 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[81]

5938 > if x != nil {

5939 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5940 if ms.LoadMessageInfo() == nil {

5943 return ms

5944 }

5945 > return mi.MessageOf(x) request_response.pb.go

5946 }

5947

5979 func (*ReapplyEventsRequest) ProtoMessage() {}

5980

5981 > func (x *ReapplyEventsRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

5982 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[82]

5983 > if x != nil {

5984 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

5985 if ms.LoadMessageInfo() == nil {

5988 return ms

5989 }

5990 > return mi.MessageOf(x) request_response.pb.go

5991 }

5992

6029 func (*ReapplyEventsResponse) ProtoMessage() {}

6030

6031 > func (x *ReapplyEventsResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6032 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[83]

6033 > if x != nil {

6034 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6035 if ms.LoadMessageInfo() == nil {

6038 return ms

6039 }

6040 > return mi.MessageOf(x) request_response.pb.go

6041 }

6042

6071 func (*GetDLQMessagesRequest) ProtoMessage() {}

6072

6073 > func (x *GetDLQMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6074 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[84]

6075 > if x != nil {

6076 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6077 if ms.LoadMessageInfo() == nil {

6080 return ms

6081 }

6082 > return mi.MessageOf(x) request_response.pb.go

6083 }

6084

6153 func (*GetDLQMessagesResponse) ProtoMessage() {}

6154

6155 > func (x *GetDLQMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6156 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[85]

6157 > if x != nil {

6158 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6159 if ms.LoadMessageInfo() == nil {

6162 return ms

6163 }

6164 > return mi.MessageOf(x) request_response.pb.go

6165 }

6166

6221 func (*PurgeDLQMessagesRequest) ProtoMessage() {}

6222

6223 > func (x *PurgeDLQMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6224 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[86]

6225 > if x != nil {

6226 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6227 if ms.LoadMessageInfo() == nil {

6230 return ms

6231 }

6232 > return mi.MessageOf(x) request_response.pb.go

6233 }

6234

6285 func (*PurgeDLQMessagesResponse) ProtoMessage() {}

6286

6287 > func (x *PurgeDLQMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6288 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[87]

6289 > if x != nil {

6290 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6291 if ms.LoadMessageInfo() == nil {

6294 return ms

6295 }

6296 > return mi.MessageOf(x) request_response.pb.go

6297 }

6298

6327 func (*MergeDLQMessagesRequest) ProtoMessage() {}

6328

6329 > func (x *MergeDLQMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6330 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[88]

6331 > if x != nil {

6332 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6333 if ms.LoadMessageInfo() == nil {

6336 return ms

6337 }

6338 > return mi.MessageOf(x) request_response.pb.go

6339 }

6340

6406 func (*MergeDLQMessagesResponse) ProtoMessage() {}

6407

6408 > func (x *MergeDLQMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6409 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[89]

6410 > if x != nil {

6411 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6412 if ms.LoadMessageInfo() == nil {

6415 return ms

6416 }

6417 > return mi.MessageOf(x) request_response.pb.go

6418 }

6419

6453 func (*RefreshWorkflowTasksRequest) ProtoMessage() {}

6454

6455 > func (x *RefreshWorkflowTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6456 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[90]

6457 > if x != nil {

6458 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6459 if ms.LoadMessageInfo() == nil {

6462 return ms

6463 }

6464 > return mi.MessageOf(x) request_response.pb.go

6465 }

6466

6510 func (*RefreshWorkflowTasksResponse) ProtoMessage() {}

6511

6512 > func (x *RefreshWorkflowTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6513 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[91]

6514 > if x != nil {

6515 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6516 if ms.LoadMessageInfo() == nil {

6519 return ms

6520 }

6521 > return mi.MessageOf(x) request_response.pb.go

6522 }

6523

6551 func (*GenerateLastHistoryReplicationTasksRequest) ProtoMessage() {}

6552

6553 > func (x *GenerateLastHistoryReplicationTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6554 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[92]

6555 > if x != nil {

6556 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6557 if ms.LoadMessageInfo() == nil {

6560 return ms

6561 }

6562 > return mi.MessageOf(x) request_response.pb.go

6563 }

6564

6617 func (*GenerateLastHistoryReplicationTasksResponse) ProtoMessage() {}

6618

6619 > func (x *GenerateLastHistoryReplicationTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6620 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[93]

6621 > if x != nil {

6622 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6623 if ms.LoadMessageInfo() == nil {

6626 return ms

6627 }

6628 > return mi.MessageOf(x) request_response.pb.go

6629 }

6630

6669 func (*GetReplicationStatusRequest) ProtoMessage() {}

6670

6671 > func (x *GetReplicationStatusRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6672 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[94]

6673 > if x != nil {

6674 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6675 if ms.LoadMessageInfo() == nil {

6678 return ms

6679 }

6680 > return mi.MessageOf(x) request_response.pb.go

6681 }

6682

6713 func (*GetReplicationStatusResponse) ProtoMessage() {}

6714

6715 > func (x *GetReplicationStatusResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6716 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[95]

6717 > if x != nil {

6718 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6719 if ms.LoadMessageInfo() == nil {

6722 return ms

6723 }

6724 > return mi.MessageOf(x) request_response.pb.go

6725 }

6726

6943 func (*RebuildMutableStateRequest) ProtoMessage() {}

6944

6945 > func (x *RebuildMutableStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

6946 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[99]

6947 > if x != nil {

6948 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6949 if ms.LoadMessageInfo() == nil {

6952 return ms

6953 }

6954 > return mi.MessageOf(x) request_response.pb.go

6955 }

6956

6993 func (*RebuildMutableStateResponse) ProtoMessage() {}

6994

6995 > func (x *RebuildMutableStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

6996 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[100]

6997 > if x != nil {

6998 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

6999 if ms.LoadMessageInfo() == nil {

7002 return ms

7003 }

7004 > return mi.MessageOf(x) request_response.pb.go

7005 }

7006

7034 func (*ImportWorkflowExecutionRequest) ProtoMessage() {}

7035

7036 > func (x *ImportWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7037 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[101]

7038 > if x != nil {

7039 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7040 if ms.LoadMessageInfo() == nil {

7043 return ms

7044 }

7045 > return mi.MessageOf(x) request_response.pb.go

7046 }

7047

7107 func (*ImportWorkflowExecutionResponse) ProtoMessage() {}

7108

7109 > func (x *ImportWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7110 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[102]

7111 > if x != nil {

7112 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7113 if ms.LoadMessageInfo() == nil {

7116 return ms

7117 }

7118 > return mi.MessageOf(x) request_response.pb.go

7119 }

7120

7161 func (*DeleteWorkflowVisibilityRecordRequest) ProtoMessage() {}

7162

7163 > func (x *DeleteWorkflowVisibilityRecordRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7164 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[103]

7165 > if x != nil {

7166 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7167 if ms.LoadMessageInfo() == nil {

7170 return ms

7171 }

7172 > return mi.MessageOf(x) request_response.pb.go

7173 }

7174

7225 func (*DeleteWorkflowVisibilityRecordResponse) ProtoMessage() {}

7226

7227 > func (x *DeleteWorkflowVisibilityRecordResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7228 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[104]

7229 > if x != nil {

7230 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7231 if ms.LoadMessageInfo() == nil {

7234 return ms

7235 }

7236 > return mi.MessageOf(x) request_response.pb.go

7237 }

7238

7266 func (*UpdateWorkflowExecutionRequest) ProtoMessage() {}

7267

7268 > func (x *UpdateWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7269 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[105]

7270 > if x != nil {

7271 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7272 if ms.LoadMessageInfo() == nil {

7275 return ms

7276 }

7277 > return mi.MessageOf(x) request_response.pb.go

7278 }

7279

7317 func (*UpdateWorkflowExecutionResponse) ProtoMessage() {}

7318

7319 > func (x *UpdateWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7320 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[106]

7321 > if x != nil {

7322 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7323 if ms.LoadMessageInfo() == nil {

7326 return ms

7327 }

7328 > return mi.MessageOf(x) request_response.pb.go

7329 }

7330

7364 func (*StreamWorkflowReplicationMessagesRequest) ProtoMessage() {}

7365

7366 > func (x *StreamWorkflowReplicationMessagesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7367 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[107]

7368 > if x != nil {

7369 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7370 if ms.LoadMessageInfo() == nil {

7373 return ms

7374 }

7375 > return mi.MessageOf(x) request_response.pb.go

7376 }

7377

7431 func (*StreamWorkflowReplicationMessagesResponse) ProtoMessage() {}

7432

7433 > func (x *StreamWorkflowReplicationMessagesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7434 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[108]

7435 > if x != nil {

7436 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7437 if ms.LoadMessageInfo() == nil {

7440 return ms

7441 }

7442 > return mi.MessageOf(x) request_response.pb.go

7443 }

7444

7496 func (*PollWorkflowExecutionUpdateRequest) ProtoMessage() {}

7497

7498 > func (x *PollWorkflowExecutionUpdateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7499 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[109]

7500 > if x != nil {

7501 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7502 if ms.LoadMessageInfo() == nil {

7505 return ms

7506 }

7507 > return mi.MessageOf(x) request_response.pb.go

7508 }

7509

7547 func (*PollWorkflowExecutionUpdateResponse) ProtoMessage() {}

7548

7549 > func (x *PollWorkflowExecutionUpdateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7550 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[110]

7551 > if x != nil {

7552 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7553 if ms.LoadMessageInfo() == nil {

7556 return ms

7557 }

7558 > return mi.MessageOf(x) request_response.pb.go

7559 }

7560

7592 func (*GetWorkflowExecutionHistoryRequest) ProtoMessage() {}

7593

7594 > func (x *GetWorkflowExecutionHistoryRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7595 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[111]

7596 > if x != nil {

7597 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7598 if ms.LoadMessageInfo() == nil {

7601 return ms

7602 }

7603 > return mi.MessageOf(x) request_response.pb.go

7604 }

7605

7644 func (*GetWorkflowExecutionHistoryResponse) ProtoMessage() {}

7645

7646 > func (x *GetWorkflowExecutionHistoryResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7647 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[112]

7648 > if x != nil {

7649 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7650 if ms.LoadMessageInfo() == nil {

7653 return ms

7654 }

7655 > return mi.MessageOf(x) request_response.pb.go

7656 }

7657

7749 func (*GetWorkflowExecutionHistoryReverseRequest) ProtoMessage() {}

7750

7751 > func (x *GetWorkflowExecutionHistoryReverseRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7752 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[114]

7753 > if x != nil {

7754 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7755 if ms.LoadMessageInfo() == nil {

7758 return ms

7759 }

7760 > return mi.MessageOf(x) request_response.pb.go

7761 }

7762

7800 func (*GetWorkflowExecutionHistoryReverseResponse) ProtoMessage() {}

7801

7802 > func (x *GetWorkflowExecutionHistoryReverseResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7803 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[115]

7804 > if x != nil {

7805 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7806 if ms.LoadMessageInfo() == nil {

7809 return ms

7810 }

7811 > return mi.MessageOf(x) request_response.pb.go

7812 }

7813

7848 func (*GetWorkflowExecutionRawHistoryV2Request) ProtoMessage() {}

7849

7850 > func (x *GetWorkflowExecutionRawHistoryV2Request) ProtoReflect() protoreflect.Message { request_response.pb.go

7851 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[116]

7852 > if x != nil {

7853 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7854 if ms.LoadMessageInfo() == nil {

7857 return ms

7858 }

7859 > return mi.MessageOf(x) request_response.pb.go

7860 }

7861

7899 func (*GetWorkflowExecutionRawHistoryV2Response) ProtoMessage() {}

7900

7901 > func (x *GetWorkflowExecutionRawHistoryV2Response) ProtoReflect() protoreflect.Message { request_response.pb.go

7902 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[117]

7903 > if x != nil {

7904 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7905 if ms.LoadMessageInfo() == nil {

7908 return ms

7909 }

7910 > return mi.MessageOf(x) request_response.pb.go

7911 }

7912

7944 func (*GetWorkflowExecutionRawHistoryRequest) ProtoMessage() {}

7945

7946 > func (x *GetWorkflowExecutionRawHistoryRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

7947 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[118]

7948 > if x != nil {

7949 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

7950 if ms.LoadMessageInfo() == nil {

7953 return ms

7954 }

7955 > return mi.MessageOf(x) request_response.pb.go

7956 }

7957

7995 func (*GetWorkflowExecutionRawHistoryResponse) ProtoMessage() {}

7996

7997 > func (x *GetWorkflowExecutionRawHistoryResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

7998 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[119]

7999 > if x != nil {

8000 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8001 if ms.LoadMessageInfo() == nil {

8004 return ms

8005 }

8006 > return mi.MessageOf(x) request_response.pb.go

8007 }

8008

8042 func (*ForceDeleteWorkflowExecutionRequest) ProtoMessage() {}

8043

8044 > func (x *ForceDeleteWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8045 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[120]

8046 > if x != nil {

8047 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8048 if ms.LoadMessageInfo() == nil {

8051 return ms

8052 }

8053 > return mi.MessageOf(x) request_response.pb.go

8054 }

8055

8100 func (*ForceDeleteWorkflowExecutionResponse) ProtoMessage() {}

8101

8102 > func (x *ForceDeleteWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8103 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[121]

8104 > if x != nil {

8105 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8106 if ms.LoadMessageInfo() == nil {

8109 return ms

8110 }

8111 > return mi.MessageOf(x) request_response.pb.go

8112 }

8113

8149 func (*DeleteExecutionRequest) ProtoMessage() {}

8150

8151 > func (x *DeleteExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8152 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[122]

8153 > if x != nil {

8154 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8155 if ms.LoadMessageInfo() == nil {

8158 return ms

8159 }

8160 > return mi.MessageOf(x) request_response.pb.go

8161 }

8162

8220 func (*DeleteExecutionResponse) ProtoMessage() {}

8221

8222 > func (x *DeleteExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8223 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[123]

8224 > if x != nil {

8225 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8226 if ms.LoadMessageInfo() == nil {

8229 return ms

8230 }

8231 > return mi.MessageOf(x) request_response.pb.go

8232 }

8233

8260 func (*GetDLQTasksRequest) ProtoMessage() {}

8261

8262 > func (x *GetDLQTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8263 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[124]

8264 > if x != nil {

8265 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8266 if ms.LoadMessageInfo() == nil {

8269 return ms

8270 }

8271 > return mi.MessageOf(x) request_response.pb.go

8272 }

8273

8322 func (*GetDLQTasksResponse) ProtoMessage() {}

8323

8324 > func (x *GetDLQTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8325 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[125]

8326 > if x != nil {

8327 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8328 if ms.LoadMessageInfo() == nil {

8331 return ms

8332 }

8333 > return mi.MessageOf(x) request_response.pb.go

8334 }

8335

8374 func (*DeleteDLQTasksRequest) ProtoMessage() {}

8375

8376 > func (x *DeleteDLQTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8377 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[126]

8378 > if x != nil {

8379 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8380 if ms.LoadMessageInfo() == nil {

8383 return ms

8384 }

8385 > return mi.MessageOf(x) request_response.pb.go

8386 }

8387

8426 func (*DeleteDLQTasksResponse) ProtoMessage() {}

8427

8428 > func (x *DeleteDLQTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8429 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[127]

8430 > if x != nil {

8431 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8432 if ms.LoadMessageInfo() == nil {

8435 return ms

8436 }

8437 > return mi.MessageOf(x) request_response.pb.go

8438 }

8439

8472 func (*ListQueuesRequest) ProtoMessage() {}

8473

8474 > func (x *ListQueuesRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8475 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[128]

8476 > if x != nil {

8477 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8478 if ms.LoadMessageInfo() == nil {

8481 return ms

8482 }

8483 > return mi.MessageOf(x) request_response.pb.go

8484 }

8485

8531 func (*ListQueuesResponse) ProtoMessage() {}

8532

8533 > func (x *ListQueuesResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8534 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[129]

8535 > if x != nil {

8536 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8537 if ms.LoadMessageInfo() == nil {

8540 return ms

8541 }

8542 > return mi.MessageOf(x) request_response.pb.go

8543 }

8544

8587 func (*AddTasksRequest) ProtoMessage() {}

8588

8589 > func (x *AddTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8590 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[130]

8591 > if x != nil {

8592 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8593 if ms.LoadMessageInfo() == nil {

8596 return ms

8597 }

8598 > return mi.MessageOf(x) request_response.pb.go

8599 }

8600

8637 func (*AddTasksResponse) ProtoMessage() {}

8638

8639 > func (x *AddTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8640 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[131]

8641 > if x != nil {

8642 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8643 if ms.LoadMessageInfo() == nil {

8646 return ms

8647 }

8648 > return mi.MessageOf(x) request_response.pb.go

8649 }

8650

8674 func (*ListTasksRequest) ProtoMessage() {}

8675

8676 > func (x *ListTasksRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8677 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[132]

8678 > if x != nil {

8679 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8680 if ms.LoadMessageInfo() == nil {

8683 return ms

8684 }

8685 > return mi.MessageOf(x) request_response.pb.go

8686 }

8687

8718 func (*ListTasksResponse) ProtoMessage() {}

8719

8720 > func (x *ListTasksResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8721 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[133]

8722 > if x != nil {

8723 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8724 if ms.LoadMessageInfo() == nil {

8727 return ms

8728 }

8729 > return mi.MessageOf(x) request_response.pb.go

8730 }

8731

8777 func (*CompleteNexusOperationChasmRequest) ProtoMessage() {}

8778

8779 > func (x *CompleteNexusOperationChasmRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8780 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[134]

8781 > if x != nil {

8782 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8783 if ms.LoadMessageInfo() == nil {

8786 return ms

8787 }

8788 > return mi.MessageOf(x) request_response.pb.go

8789 }

8790

8891 func (*CompleteNexusOperationChasmResponse) ProtoMessage() {}

8892

8893 > func (x *CompleteNexusOperationChasmResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

8894 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[135]

8895 > if x != nil {

8896 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8897 if ms.LoadMessageInfo() == nil {

8900 return ms

8901 }

8902 > return mi.MessageOf(x) request_response.pb.go

8903 }

8904

8942 func (*CompleteNexusOperationRequest) ProtoMessage() {}

8943

8944 > func (x *CompleteNexusOperationRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

8945 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[136]

8946 > if x != nil {

8947 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

8948 if ms.LoadMessageInfo() == nil {

8951 return ms

8952 }

8953 > return mi.MessageOf(x) request_response.pb.go

8954 }

8955

9056 func (*CompleteNexusOperationResponse) ProtoMessage() {}

9057

9058 > func (x *CompleteNexusOperationResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9059 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[137]

9060 > if x != nil {

9061 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9062 if ms.LoadMessageInfo() == nil {

9065 return ms

9066 }

9067 > return mi.MessageOf(x) request_response.pb.go

9068 }

9069

9109 func (*InvokeStateMachineMethodRequest) ProtoMessage() {}

9110

9111 > func (x *InvokeStateMachineMethodRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9112 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[138]

9113 > if x != nil {

9114 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9115 if ms.LoadMessageInfo() == nil {

9118 return ms

9119 }

9120 > return mi.MessageOf(x) request_response.pb.go

9121 }

9122

9189 func (*InvokeStateMachineMethodResponse) ProtoMessage() {}

9190

9191 > func (x *InvokeStateMachineMethodResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9192 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[139]

9193 > if x != nil {

9194 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9195 if ms.LoadMessageInfo() == nil {

9198 return ms

9199 }

9200 > return mi.MessageOf(x) request_response.pb.go

9201 }

9202

9233 func (*DeepHealthCheckRequest) ProtoMessage() {}

9234

9235 > func (x *DeepHealthCheckRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9236 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[140]

9237 > if x != nil {

9238 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9239 if ms.LoadMessageInfo() == nil {

9242 return ms

9243 }

9244 > return mi.MessageOf(x) request_response.pb.go

9245 }

9246

9279 func (*DeepHealthCheckResponse) ProtoMessage() {}

9280

9281 > func (x *DeepHealthCheckResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9282 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[141]

9283 > if x != nil {

9284 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9285 if ms.LoadMessageInfo() == nil {

9288 return ms

9289 }

9290 > return mi.MessageOf(x) request_response.pb.go

9291 }

9292

9336 func (*SyncWorkflowStateRequest) ProtoMessage() {}

9337

9338 > func (x *SyncWorkflowStateRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9339 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[142]

9340 > if x != nil {

9341 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9342 if ms.LoadMessageInfo() == nil {

9345 return ms

9346 }

9347 > return mi.MessageOf(x) request_response.pb.go

9348 }

9349

9415 func (*SyncWorkflowStateResponse) ProtoMessage() {}

9416

9417 > func (x *SyncWorkflowStateResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9418 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[143]

9419 > if x != nil {

9420 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9421 if ms.LoadMessageInfo() == nil {

9424 return ms

9425 }

9426 > return mi.MessageOf(x) request_response.pb.go

9427 }

9428

9463 func (*UpdateActivityOptionsRequest) ProtoMessage() {}

9464

9465 > func (x *UpdateActivityOptionsRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9466 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[144]

9467 > if x != nil {

9468 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9469 if ms.LoadMessageInfo() == nil {

9472 return ms

9473 }

9474 > return mi.MessageOf(x) request_response.pb.go

9475 }

9476

9515 func (*UpdateActivityOptionsResponse) ProtoMessage() {}

9516

9517 > func (x *UpdateActivityOptionsResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9518 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[145]

9519 > if x != nil {

9520 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9521 if ms.LoadMessageInfo() == nil {

9524 return ms

9525 }

9526 > return mi.MessageOf(x) request_response.pb.go

9527 }

9528

9561 func (*PauseActivityRequest) ProtoMessage() {}

9562

9563 > func (x *PauseActivityRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9564 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[146]

9565 > if x != nil {

9566 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9567 if ms.LoadMessageInfo() == nil {

9570 return ms

9571 }

9572 > return mi.MessageOf(x) request_response.pb.go

9573 }

9574

9611 func (*PauseActivityResponse) ProtoMessage() {}

9612

9613 > func (x *PauseActivityResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9614 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[147]

9615 > if x != nil {

9616 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9617 if ms.LoadMessageInfo() == nil {

9620 return ms

9621 }

9622 > return mi.MessageOf(x) request_response.pb.go

9623 }

9624

9650 func (*UnpauseActivityRequest) ProtoMessage() {}

9651

9652 > func (x *UnpauseActivityRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9653 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[148]

9654 > if x != nil {

9655 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9656 if ms.LoadMessageInfo() == nil {

9659 return ms

9660 }

9661 > return mi.MessageOf(x) request_response.pb.go

9662 }

9663

9700 func (*UnpauseActivityResponse) ProtoMessage() {}

9701

9702 > func (x *UnpauseActivityResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9703 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[149]

9704 > if x != nil {

9705 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9706 if ms.LoadMessageInfo() == nil {

9709 return ms

9710 }

9711 > return mi.MessageOf(x) request_response.pb.go

9712 }

9713

9739 func (*ResetActivityRequest) ProtoMessage() {}

9740

9741 > func (x *ResetActivityRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9742 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[150]

9743 > if x != nil {

9744 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9745 if ms.LoadMessageInfo() == nil {

9748 return ms

9749 }

9750 > return mi.MessageOf(x) request_response.pb.go

9751 }

9752

9789 func (*ResetActivityResponse) ProtoMessage() {}

9790

9791 > func (x *ResetActivityResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9792 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[151]

9793 > if x != nil {

9794 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9795 if ms.LoadMessageInfo() == nil {

9798 return ms

9799 }

9800 > return mi.MessageOf(x) request_response.pb.go

9801 }

9802

9829 func (*UpdateWorkflowExecutionOptionsRequest) ProtoMessage() {}

9830

9831 > func (x *UpdateWorkflowExecutionOptionsRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9832 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[152]

9833 > if x != nil {

9834 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9835 if ms.LoadMessageInfo() == nil {

9838 return ms

9839 }

9840 > return mi.MessageOf(x) request_response.pb.go

9841 }

9842

9884 func (*UpdateWorkflowExecutionOptionsResponse) ProtoMessage() {}

9885

9886 > func (x *UpdateWorkflowExecutionOptionsResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9887 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[153]

9888 > if x != nil {

9889 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9890 if ms.LoadMessageInfo() == nil {

9893 return ms

9894 }

9895 > return mi.MessageOf(x) request_response.pb.go

9896 }

9897

9937 func (*PauseWorkflowExecutionRequest) ProtoMessage() {}

9938

9939 > func (x *PauseWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

9940 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[154]

9941 > if x != nil {

9942 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9943 if ms.LoadMessageInfo() == nil {

9946 return ms

9947 }

9948 > return mi.MessageOf(x) request_response.pb.go

9949 }

9950

9987 func (*PauseWorkflowExecutionResponse) ProtoMessage() {}

9988

9989 > func (x *PauseWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

9990 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[155]

9991 > if x != nil {

9992 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

9993 if ms.LoadMessageInfo() == nil {

9996 return ms

9997 }

9998 > return mi.MessageOf(x) request_response.pb.go

9999 }

10000

10026 func (*UnpauseWorkflowExecutionRequest) ProtoMessage() {}

10027

10028 > func (x *UnpauseWorkflowExecutionRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

10029 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[156]

10030 > if x != nil {

10031 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10032 if ms.LoadMessageInfo() == nil {

10035 return ms

10036 }

10037 > return mi.MessageOf(x) request_response.pb.go

10038 }

10039

10076 func (*UnpauseWorkflowExecutionResponse) ProtoMessage() {}

10077

10078 > func (x *UnpauseWorkflowExecutionResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

10079 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[157]

10080 > if x != nil {

10081 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10082 if ms.LoadMessageInfo() == nil {

10085 return ms

10086 }

10087 > return mi.MessageOf(x) request_response.pb.go

10088 }

10089

10115 func (*StartNexusOperationRequest) ProtoMessage() {}

10116

10117 > func (x *StartNexusOperationRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

10118 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[158]

10119 > if x != nil {

10120 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10121 if ms.LoadMessageInfo() == nil {

10124 return ms

10125 }

10126 > return mi.MessageOf(x) request_response.pb.go

10127 }

10128

10173 func (*StartNexusOperationResponse) ProtoMessage() {}

10174

10175 > func (x *StartNexusOperationResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

10176 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[159]

10177 > if x != nil {

10178 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10179 if ms.LoadMessageInfo() == nil {

10182 return ms

10183 }

10184 > return mi.MessageOf(x) request_response.pb.go

10185 }

10186

10219 func (*CancelNexusOperationRequest) ProtoMessage() {}

10220

10221 > func (x *CancelNexusOperationRequest) ProtoReflect() protoreflect.Message { request_response.pb.go

10222 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[160]

10223 > if x != nil {

10224 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10225 if ms.LoadMessageInfo() == nil {

10228 return ms

10229 }

10230 > return mi.MessageOf(x) request_response.pb.go

10231 }

10232

10277 func (*CancelNexusOperationResponse) ProtoMessage() {}

10278

10279 > func (x *CancelNexusOperationResponse) ProtoReflect() protoreflect.Message { request_response.pb.go

10280 > mi := &file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[161]

10281 > if x != nil {

10282 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))

10283 if ms.LoadMessageInfo() == nil {

10286 return ms

10287 }

10288 > return mi.MessageOf(x) request_response.pb.go

10289 }

10290

11956 }

11957

11958 > func init() { file_temporal_server_api_historyservice_v1_request_response_proto_init() } request_response.pb.go

11959 > func file_temporal_server_api_historyservice_v1_request_response_proto_init() {

11960 > if File_temporal_server_api_historyservice_v1_request_response_proto != nil {

11961 > return

11962 > }

11963 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[107].OneofWrappers = []any{

11964 > (*StreamWorkflowReplicationMessagesRequest_SyncReplicationState)(nil),

11965 > }

11966 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[108].OneofWrappers = []any{

11967 > (*StreamWorkflowReplicationMessagesResponse_Messages)(nil),

11968 > }

11969 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[134].OneofWrappers = []any{

11970 > (*CompleteNexusOperationChasmRequest_Success)(nil),

11971 > (*CompleteNexusOperationChasmRequest_Failure)(nil),

11972 > }

11973 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[136].OneofWrappers = []any{

11974 > (*CompleteNexusOperationRequest_Success)(nil),

11975 > (*CompleteNexusOperationRequest_Failure)(nil),

11976 > }

11977 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[162].OneofWrappers = []any{

11978 > (*ExecuteMultiOperationRequest_Operation_StartWorkflow)(nil),

11979 > (*ExecuteMultiOperationRequest_Operation_UpdateWorkflow)(nil),

11980 > }

11981 > file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes[163].OneofWrappers = []any{

11982 > (*ExecuteMultiOperationResponse_Response_StartWorkflow)(nil),

11983 > (*ExecuteMultiOperationResponse_Response_UpdateWorkflow)(nil),

11984 > }

11985 > type x struct{}

11986 > out := protoimpl.TypeBuilder{

11987 > File: protoimpl.DescBuilder{

11988 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

11989 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc), len(file_temporal_server_api_historyservice_v1_request_response_proto_rawDesc)),

11990 > NumEnums: 0,

11991 > NumMessages: 171,

11992 > NumExtensions: 1,

11993 > NumServices: 0,

11994 > },

11995 > GoTypes: file_temporal_server_api_historyservice_v1_request_response_proto_goTypes,

11996 > DependencyIndexes: file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs,

11997 > MessageInfos: file_temporal_server_api_historyservice_v1_request_response_proto_msgTypes,

11998 > ExtensionInfos: file_temporal_server_api_historyservice_v1_request_response_proto_extTypes,

11999 > }.Build()

12000 > File_temporal_server_api_historyservice_v1_request_response_proto = out.File

12001 > file_temporal_server_api_historyservice_v1_request_response_proto_goTypes = nil

12002 > file_temporal_server_api_historyservice_v1_request_response_proto_depIdxs = nil

12003 }