diff --git a/.dapr-proto-ref b/.dapr-proto-ref new file mode 100644 index 00000000..02dcc973 --- /dev/null +++ b/.dapr-proto-ref @@ -0,0 +1 @@ +ac5845ff5c5617c4c949c82e4e331dca5dddfc8d diff --git a/.github/workflows/test-on-push.yaml b/.github/workflows/test-on-push.yaml index 617ece29..9c3cf6b2 100644 --- a/.github/workflows/test-on-push.yaml +++ b/.github/workflows/test-on-push.yaml @@ -44,3 +44,7 @@ jobs: run: make modtidy check-diff - name: Run go mod tidy run: make modtidy + + - name: Run make proto check diff + uses: bufbuild/buf-action@v1 + run: make proto-check-diff diff --git a/Makefile b/Makefile index 5c1ee974..4088b808 100644 --- a/Makefile +++ b/Makefile @@ -61,3 +61,34 @@ check-diff: .PHONY: modtidy modtidy: go mod tidy + +.PHONY: proto +proto: + @command -v buf >/dev/null 2>&1 || { echo "buf is not installed. Install it from https://docs.buf.build/installation"; exit 1; } + @if [ ! -f .dapr-proto-ref ]; then echo "No .dapr-proto-ref file found. Run 'make proto-update' first."; exit 1; fi + @find ./internal/proto -type f -name '*.go' -delete + @COMMIT=$$(cat .dapr-proto-ref | tr -d '\n'); \ + buf generate \ + --template buf.gen.yaml \ + --path dapr/proto/common/v1 \ + --path dapr/proto/runtime/v1 \ + "https://github.com/dapr/dapr.git#commit=$$COMMIT" + +.PHONY: proto-update +proto-update: + @echo "Updating Dapr to latest commit..." + @git ls-remote https://github.com/dapr/dapr.git HEAD | cut -f1 > .dapr-proto-ref + @echo "Updated .dapr-proto-ref to: $$(cat .dapr-proto-ref)" + @$(MAKE) proto + +PROTO_PATH := internal/proto +.PHONY: proto-check-diff +proto-check-diff: + @$(MAKE) proto + @# single‐shell if…then…fi block + @if ! git diff --quiet -- $(PROTO_PATH); then \ + echo "::error ::Proto files are out of date. Please run 'make proto' and commit the changes."; \ + git --no-pager diff -- $(PROTO_PATH); \ + exit 1; \ + fi + diff --git a/buf.gen.yaml b/buf.gen.yaml new file mode 100644 index 00000000..778b14e9 --- /dev/null +++ b/buf.gen.yaml @@ -0,0 +1,15 @@ +version: v2 +managed: + enabled: true + override: + - file_option: go_package_prefix + value: github.com/dapr/go-sdk/internal/proto +plugins: + - remote: buf.build/protocolbuffers/go + out: internal/proto + opt: + - paths=source_relative + - remote: buf.build/grpc/go + out: internal/proto + opt: + - paths=source_relative diff --git a/client/actor.go b/client/actor.go index 940c20e1..bcc5dd33 100644 --- a/client/actor.go +++ b/client/actor.go @@ -22,10 +22,10 @@ import ( "google.golang.org/protobuf/types/known/anypb" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" "github.com/dapr/go-sdk/actor" "github.com/dapr/go-sdk/actor/codec" "github.com/dapr/go-sdk/actor/config" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/client/binding.go b/client/binding.go index 24c82a78..e44ec714 100644 --- a/client/binding.go +++ b/client/binding.go @@ -18,7 +18,7 @@ import ( "errors" "fmt" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // InvokeBindingRequest represents binding invocation request. diff --git a/client/client.go b/client/client.go index 4b8215ec..f1a0cb02 100644 --- a/client/client.go +++ b/client/client.go @@ -37,7 +37,7 @@ import ( "google.golang.org/grpc/credentials/insecure" "google.golang.org/grpc/metadata" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" // used to import codec implements. _ "github.com/dapr/go-sdk/actor/codec/impl" diff --git a/client/client_test.go b/client/client_test.go index 9161e056..af66c6af 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -35,8 +35,8 @@ import ( "google.golang.org/protobuf/types/known/durationpb" "google.golang.org/protobuf/types/known/emptypb" - commonv1pb "github.com/dapr/dapr/pkg/proto/common/v1" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + commonv1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/client/configuration.go b/client/configuration.go index b5344945..dcaa91bf 100644 --- a/client/configuration.go +++ b/client/configuration.go @@ -6,7 +6,7 @@ import ( "fmt" "io" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) type ConfigurationItem struct { diff --git a/client/conversation.go b/client/conversation.go index 01094268..3cfab126 100644 --- a/client/conversation.go +++ b/client/conversation.go @@ -18,7 +18,7 @@ import ( "google.golang.org/protobuf/types/known/anypb" - runtimev1pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + runtimev1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // conversationRequest object - currently unexported as used in a functions option pattern diff --git a/client/crypto.go b/client/crypto.go index 41ffcf2d..517a3144 100644 --- a/client/crypto.go +++ b/client/crypto.go @@ -22,8 +22,9 @@ import ( "google.golang.org/grpc" "google.golang.org/protobuf/proto" - commonv1pb "github.com/dapr/dapr/pkg/proto/common/v1" - runtimev1pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + "github.com/dapr/go-sdk/client/internal/crypto" + commonv1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + runtimev1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // Encrypt data read from a stream, returning a readable stream that receives the encrypted data. @@ -48,9 +49,11 @@ func (c *GRPCClient) Encrypt(ctx context.Context, in io.Reader, opts EncryptOpti } // Use the context of the stream here. - return c.performCryptoOperation( - stream.Context(), stream, - in, opts, + return performCryptoOperation( + stream.Context(), + stream, + in, + opts, &runtimev1pb.EncryptRequest{}, &runtimev1pb.EncryptResponse{}, ) @@ -72,15 +75,24 @@ func (c *GRPCClient) Decrypt(ctx context.Context, in io.Reader, opts DecryptOpti } // Use the context of the stream here. - return c.performCryptoOperation( - stream.Context(), stream, - in, opts, + return performCryptoOperation( + stream.Context(), + stream, + in, + opts, &runtimev1pb.DecryptRequest{}, &runtimev1pb.DecryptResponse{}, ) } -func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.ClientStream, in io.Reader, opts cryptoOperationOpts, reqProto runtimev1pb.CryptoRequests, resProto runtimev1pb.CryptoResponses) (io.Reader, error) { +func performCryptoOperation[T runtimev1pb.DecryptRequest | runtimev1pb.EncryptRequest, Y runtimev1pb.DecryptResponse | runtimev1pb.EncryptResponse]( + ctx context.Context, + stream grpc.ClientStream, + in io.Reader, + opts cryptoOperationOpts, + reqProto *T, + resProto *Y, +) (io.Reader, error) { var err error // Pipe for writing the response pr, pw := io.Pipe() @@ -110,11 +122,11 @@ func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.Cli // First message only - add the options if optsProto != nil { - reqProto.SetOptions(optsProto) + crypto.SetOptions(reqProto, optsProto) optsProto = nil } else { // Reset the object so we can re-use it - reqProto.Reset() + crypto.Reset(reqProto) } n, err = in.Read(*reqBuf) @@ -127,7 +139,7 @@ func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.Cli // Send the chunk if there's anything to send if n > 0 { - reqProto.SetPayload(&commonv1pb.StreamPayload{ + crypto.SetPayload(reqProto, &commonv1pb.StreamPayload{ Data: (*reqBuf)[:n], Seq: seq, }) @@ -184,7 +196,7 @@ func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.Cli } // Write the data, if any, into the pipe - payload = resProto.GetPayload() + payload = crypto.GetPayload(resProto) if payload != nil { if payload.GetSeq() != expectSeq { pw.CloseWithError(fmt.Errorf("invalid sequence number in chunk: %d (expected: %d)", payload.GetSeq(), expectSeq)) @@ -205,7 +217,7 @@ func (c *GRPCClient) performCryptoOperation(ctx context.Context, stream grpc.Cli } // Reset the proto - resProto.Reset() + crypto.Reset(resProto) } // Close the writer of the pipe when done diff --git a/client/crypto_test.go b/client/crypto_test.go index b823faa0..a14552a4 100644 --- a/client/crypto_test.go +++ b/client/crypto_test.go @@ -25,8 +25,9 @@ import ( "github.com/stretchr/testify/require" "google.golang.org/grpc" - commonv1 "github.com/dapr/dapr/pkg/proto/common/v1" - runtimev1pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + "github.com/dapr/go-sdk/client/internal/crypto" + commonv1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + runtimev1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) func TestEncrypt(t *testing.T) { @@ -189,7 +190,7 @@ func TestDecrypt(t *testing.T) { /* --- Server methods --- */ func (s *testDaprServer) EncryptAlpha1(stream runtimev1pb.Dapr_EncryptAlpha1Server) error { - return s.performCryptoOperation( + return testPerformCryptoOperation( stream, &runtimev1pb.EncryptRequest{}, &runtimev1pb.EncryptResponse{}, @@ -197,14 +198,16 @@ func (s *testDaprServer) EncryptAlpha1(stream runtimev1pb.Dapr_EncryptAlpha1Serv } func (s *testDaprServer) DecryptAlpha1(stream runtimev1pb.Dapr_DecryptAlpha1Server) error { - return s.performCryptoOperation( + return testPerformCryptoOperation( stream, &runtimev1pb.DecryptRequest{}, &runtimev1pb.DecryptResponse{}, ) } -func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqProto runtimev1pb.CryptoRequests, resProto runtimev1pb.CryptoResponses) error { +func testPerformCryptoOperation[T runtimev1pb.DecryptRequest | runtimev1pb.EncryptRequest, Y runtimev1pb.DecryptResponse | runtimev1pb.EncryptResponse]( + stream grpc.ServerStream, reqProto *T, resProto *Y, +) error { // This doesn't really encrypt or decrypt the data and just sends back whatever it receives pr, pw := io.Pipe() @@ -216,7 +219,7 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro ) first := true for !done && stream.Context().Err() == nil { - reqProto.Reset() + crypto.Reset(reqProto) err = stream.RecvMsg(reqProto) if errors.Is(err, io.EOF) { done = true @@ -225,16 +228,16 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro return } - if first && !reqProto.HasOptions() { + if first && !hasOptions(reqProto) { pw.CloseWithError(errors.New("first message must have options")) return - } else if !first && reqProto.HasOptions() { + } else if !first && hasOptions(reqProto) { pw.CloseWithError(errors.New("messages after first must not have options")) return } first = false - payload := reqProto.GetPayload() + payload := crypto.GetPayload(reqProto) if payload != nil { if payload.GetSeq() != expectSeq { pw.CloseWithError(fmt.Errorf("invalid sequence number: %d (expected: %d)", payload.GetSeq(), expectSeq)) @@ -261,7 +264,7 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro ) buf := make([]byte, 2<<10) for !done && stream.Context().Err() == nil { - resProto.Reset() + crypto.Reset(resProto) n, err = pr.Read(buf) if errors.Is(err, io.EOF) { @@ -271,7 +274,7 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro } if n > 0 { - resProto.SetPayload(&commonv1.StreamPayload{ + crypto.SetPayload(resProto, &commonv1.StreamPayload{ Seq: seq, Data: buf[:n], }) @@ -286,3 +289,18 @@ func (s *testDaprServer) performCryptoOperation(stream grpc.ServerStream, reqPro return nil } + +func hasOptions[T runtimev1pb.DecryptRequest | runtimev1pb.EncryptRequest](msg *T) bool { + if msg == nil { + return false + } + + switch r := any(msg).(type) { + case *runtimev1pb.EncryptRequest: + return r.GetOptions() != nil + case *runtimev1pb.DecryptRequest: + return r.GetOptions() != nil + } + + return false +} diff --git a/client/internal/crypto/helpers.go b/client/internal/crypto/helpers.go new file mode 100644 index 00000000..0e342928 --- /dev/null +++ b/client/internal/crypto/helpers.go @@ -0,0 +1,83 @@ +// Package crypto was introduced when removing the code dependency to the +// generated protos from the dapr/dapr repository. +// It contains helper methods that are meant to replace the custom changes +// introduced by the protos on that repo at: +// https://github.com/dapr/dapr/blob/db5361701c55cae8ad21be60e2d4557f98cbc741/pkg/proto/runtime/v1/dapr_additional.go. +package crypto + +import ( + "google.golang.org/protobuf/proto" + + commonv1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + runtimev1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" +) + +// GetPayload will retrieve the payload from one of the given runtime proto message. +func GetPayload[T runtimev1.DecryptRequest | runtimev1.EncryptRequest | runtimev1.DecryptResponse | runtimev1.EncryptResponse](req *T) *commonv1pb.StreamPayload { + if req == nil { + return nil + } + + switch r := any(req).(type) { + case *runtimev1.EncryptRequest: + return r.GetPayload() + case *runtimev1.DecryptRequest: + return r.GetPayload() + case *runtimev1.EncryptResponse: + return r.GetPayload() + case *runtimev1.DecryptResponse: + return r.GetPayload() + } + + return nil +} + +// SetPayload will set the payload for one of the given runtime proto message. +func SetPayload[T runtimev1.DecryptRequest | runtimev1.EncryptRequest | runtimev1.DecryptResponse | runtimev1.EncryptResponse](req *T, payload *commonv1pb.StreamPayload) { + if req == nil { + return + } + + switch r := any(req).(type) { + case *runtimev1.EncryptRequest: + r.Payload = payload + case *runtimev1.DecryptRequest: + r.Payload = payload + case *runtimev1.EncryptResponse: + r.Payload = payload + case *runtimev1.DecryptResponse: + r.Payload = payload + } +} + +// SetOptions will set the options for one of the given runtime proto message. +func SetOptions[T runtimev1.DecryptRequest | runtimev1.EncryptRequest](req *T, opts proto.Message) { + if req == nil { + return + } + + switch r := any(req).(type) { + case *runtimev1.EncryptRequest: + r.Options = opts.(*runtimev1.EncryptRequestOptions) + case *runtimev1.DecryptRequest: + r.Options = opts.(*runtimev1.DecryptRequestOptions) + } +} + +// Reset will call the `Reset` method in the given runtime proto message. +func Reset[T runtimev1.DecryptRequest | runtimev1.EncryptRequest | runtimev1.DecryptResponse | runtimev1.EncryptResponse](msg *T) { + if msg == nil { + return + } + + switch r := any(msg).(type) { + case *runtimev1.EncryptRequest: + r.Reset() + case *runtimev1.DecryptRequest: + r.Reset() + case *runtimev1.EncryptResponse: + r.Reset() + case *runtimev1.DecryptResponse: + r.Reset() + } +} diff --git a/client/internal/crypto/helpers_test.go b/client/internal/crypto/helpers_test.go new file mode 100644 index 00000000..51f546f3 --- /dev/null +++ b/client/internal/crypto/helpers_test.go @@ -0,0 +1,185 @@ +package crypto_test + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/proto" + + "github.com/dapr/go-sdk/client/internal/crypto" + commonv1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + runtimev1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" +) + +func TestPayloadMethods(t *testing.T) { + testCases := map[string]struct { + protoMsg any + inputData []byte + }{ + "EncryptRequest": { + protoMsg: &runtimev1.EncryptRequest{}, + inputData: []byte("test data"), + }, + "EncryptResponse": { + protoMsg: &runtimev1.EncryptResponse{}, + inputData: []byte("test data"), + }, + "DecryptRequest": { + protoMsg: &runtimev1.DecryptRequest{}, + inputData: []byte("test data"), + }, + "DecryptResponse": { + protoMsg: &runtimev1.DecryptResponse{}, + inputData: []byte("test data"), + }, + "with nil proto message": { + protoMsg: nilValue[runtimev1.EncryptRequest](), + inputData: []byte("test data"), + }, + "with nil input data": { + protoMsg: &runtimev1.EncryptRequest{}, + inputData: nil, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + inputPayload := &commonv1.StreamPayload{Data: tc.inputData} + var outputPayload *commonv1.StreamPayload + + switch r := tc.protoMsg.(type) { + case *runtimev1.EncryptRequest: + crypto.SetPayload(r, inputPayload) + outputPayload = crypto.GetPayload(r) + case *runtimev1.EncryptResponse: + crypto.SetPayload(r, inputPayload) + outputPayload = crypto.GetPayload(r) + case *runtimev1.DecryptRequest: + crypto.SetPayload(r, inputPayload) + outputPayload = crypto.GetPayload(r) + case *runtimev1.DecryptResponse: + crypto.SetPayload(r, inputPayload) + outputPayload = crypto.GetPayload(r) + default: + require.Failf(t, "unsupported proto message type", "the type was %T", r) + } + + if reflect.ValueOf(tc.protoMsg).IsNil() { + assert.Nil(t, outputPayload.GetData(), "the payload should be nil") + return + } + + assert.Equal(t, tc.inputData, outputPayload.GetData(), "payload should match the input") + }) + } +} + +func TestSetOptions(t *testing.T) { + testCases := map[string]struct { + protoMsg any + options proto.Message + }{ + "EncryptRequest": { + protoMsg: &runtimev1.EncryptRequest{}, + options: &runtimev1.EncryptRequestOptions{ + KeyName: "testing", + }, + }, + "DecryptRequest": { + protoMsg: &runtimev1.DecryptRequest{}, + options: &runtimev1.DecryptRequestOptions{ + KeyName: "testing", + }, + }, + "with nil proto message": { + protoMsg: nilValue[runtimev1.EncryptRequest](), + options: &runtimev1.EncryptRequestOptions{ + KeyName: "testing", + }, + }, + "with nil options": { + protoMsg: &runtimev1.EncryptRequest{}, + options: nilValue[runtimev1.EncryptRequestOptions](), + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + var outputOptions proto.Message + + switch r := tc.protoMsg.(type) { + case *runtimev1.EncryptRequest: + crypto.SetOptions(r, tc.options) + outputOptions = r.GetOptions() + case *runtimev1.DecryptRequest: + crypto.SetOptions(r, tc.options) + outputOptions = r.GetOptions() + default: + require.Failf(t, "unsupported proto message type", "the type was %T", r) + } + + if reflect.ValueOf(tc.protoMsg).IsNil() { + assert.Nil(t, outputOptions, "the payload should be nil") + return + } + + assert.Equal(t, tc.options, outputOptions, "options should be persisted") + }) + } +} + +func TestReset(t *testing.T) { + testCases := map[string]struct { + protoMsg any + }{ + "EncryptRequest": { + protoMsg: &runtimev1.EncryptRequest{Payload: &commonv1.StreamPayload{Data: []byte("test data")}}, + }, + "EncryptResponse": { + protoMsg: &runtimev1.EncryptResponse{Payload: &commonv1.StreamPayload{Data: []byte("test data")}}, + }, + "DecryptRequest": { + protoMsg: &runtimev1.DecryptRequest{Payload: &commonv1.StreamPayload{Data: []byte("test data")}}, + }, + "DecryptResponse": { + protoMsg: &runtimev1.DecryptResponse{Payload: &commonv1.StreamPayload{Data: []byte("test data")}}, + }, + "with nil proto message": { + protoMsg: nilValue[runtimev1.EncryptRequest](), + }, + "with nil payload": { + protoMsg: &runtimev1.EncryptRequest{Payload: nil}, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + var payload *commonv1.StreamPayload + + switch r := tc.protoMsg.(type) { + case *runtimev1.EncryptRequest: + crypto.Reset(r) + payload = crypto.GetPayload(r) + case *runtimev1.EncryptResponse: + crypto.Reset(r) + payload = crypto.GetPayload(r) + case *runtimev1.DecryptRequest: + crypto.Reset(r) + payload = crypto.GetPayload(r) + case *runtimev1.DecryptResponse: + crypto.Reset(r) + payload = crypto.GetPayload(r) + default: + require.Failf(t, "unsupported proto message type", "the type was %T", r) + } + + assert.Nil(t, payload) + }) + } +} + +func nilValue[T any]() *T { + return nil +} diff --git a/client/invoke.go b/client/invoke.go index e4f674a3..13d4f3c6 100644 --- a/client/invoke.go +++ b/client/invoke.go @@ -22,8 +22,8 @@ import ( "google.golang.org/protobuf/types/known/anypb" - v1 "github.com/dapr/dapr/pkg/proto/common/v1" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // DataContent the service invocation content. diff --git a/client/invoke_test.go b/client/invoke_test.go index 8438c08d..a323335d 100644 --- a/client/invoke_test.go +++ b/client/invoke_test.go @@ -20,7 +20,7 @@ import ( "github.com/stretchr/testify/assert" - v1 "github.com/dapr/dapr/pkg/proto/common/v1" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" ) type _testStructwithText struct { diff --git a/client/jobs.go b/client/jobs.go index 1bf65398..9bca4179 100644 --- a/client/jobs.go +++ b/client/jobs.go @@ -21,8 +21,8 @@ import ( "google.golang.org/protobuf/types/known/anypb" "google.golang.org/protobuf/types/known/durationpb" - commonpb "github.com/dapr/dapr/pkg/proto/common/v1" - runtimepb "github.com/dapr/dapr/pkg/proto/runtime/v1" + commonpb "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + runtimepb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/kit/ptr" ) diff --git a/client/lock.go b/client/lock.go index 26ca8614..80b4ee99 100644 --- a/client/lock.go +++ b/client/lock.go @@ -18,7 +18,7 @@ import ( "errors" "fmt" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // LockRequest is the lock request object. diff --git a/client/lock_test.go b/client/lock_test.go index 75ae1c87..bc55db28 100644 --- a/client/lock_test.go +++ b/client/lock_test.go @@ -20,7 +20,7 @@ import ( "github.com/stretchr/testify/assert" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/client/metadata.go b/client/metadata.go index fd8080b1..38207b35 100644 --- a/client/metadata.go +++ b/client/metadata.go @@ -5,7 +5,7 @@ import ( "errors" "fmt" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) type GetMetadataResponse struct { diff --git a/client/pubsub.go b/client/pubsub.go index 11b7ac54..386fa182 100644 --- a/client/pubsub.go +++ b/client/pubsub.go @@ -22,7 +22,7 @@ import ( "github.com/google/uuid" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/client/secret.go b/client/secret.go index ebffb931..52361dc4 100644 --- a/client/secret.go +++ b/client/secret.go @@ -18,7 +18,7 @@ import ( "errors" "fmt" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) // GetSecret retrieves preconfigured secret from specified store using key. diff --git a/client/state.go b/client/state.go index 66377a0c..184ba6ae 100644 --- a/client/state.go +++ b/client/state.go @@ -18,8 +18,8 @@ import ( "errors" "fmt" - v1 "github.com/dapr/dapr/pkg/proto/common/v1" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/client/state_test.go b/client/state_test.go index 0edf7f09..4749e3b5 100644 --- a/client/state_test.go +++ b/client/state_test.go @@ -22,7 +22,7 @@ import ( "github.com/stretchr/testify/assert" - v1 "github.com/dapr/dapr/pkg/proto/common/v1" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" ) const ( diff --git a/client/subscribe.go b/client/subscribe.go index 4bfa48d9..b1ebbfc3 100644 --- a/client/subscribe.go +++ b/client/subscribe.go @@ -26,7 +26,7 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) diff --git a/client/workflow.go b/client/workflow.go index 75b105d3..3b4ac2b3 100644 --- a/client/workflow.go +++ b/client/workflow.go @@ -23,7 +23,7 @@ import ( "github.com/google/uuid" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" ) const ( diff --git a/examples/go.mod b/examples/go.mod index ca51ced0..b9ff58be 100644 --- a/examples/go.mod +++ b/examples/go.mod @@ -18,10 +18,10 @@ require ( github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b // indirect github.com/dapr/durabletask-go v0.7.2 // indirect github.com/dapr/kit v0.15.4 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/fsnotify/fsnotify v1.9.0 // indirect github.com/go-chi/chi/v5 v5.1.0 // indirect github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect diff --git a/examples/go.sum b/examples/go.sum index 541518a5..199d4f3d 100644 --- a/examples/go.sum +++ b/examples/go.sum @@ -6,8 +6,6 @@ github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK3 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b h1:fR+ae4QXF8R4GqKrzEls7WaibF1wjiVvifUl+IoP37I= -github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b/go.mod h1:kx/7l7wDGkKRVoE6CUtuNl1FjKA0hj7bn/6xJ1Fc6HY= github.com/dapr/durabletask-go v0.7.2 h1:ssNupibV65/o5HNJRceU6x7D4LSyrGsz6nfMFUcI540= github.com/dapr/durabletask-go v0.7.2/go.mod h1:JhMyDybRUFmmgieGxCPeg9e2cWwtx4LwNXjD+LBtKYk= github.com/dapr/kit v0.15.4 h1:29DezCR22OuZhXX4yPEc+lqcOf/PNaeAuIEx9nGv394= diff --git a/go.mod b/go.mod index bd5152e1..d5b4e6ed 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,6 @@ module github.com/dapr/go-sdk go 1.24.4 require ( - github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b github.com/dapr/durabletask-go v0.7.2 github.com/dapr/kit v0.15.4 github.com/go-chi/chi/v5 v5.1.0 @@ -26,6 +25,7 @@ require ( go.opentelemetry.io/otel v1.36.0 // indirect go.opentelemetry.io/otel/metric v1.36.0 // indirect go.opentelemetry.io/otel/trace v1.36.0 // indirect + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect golang.org/x/net v0.41.0 // indirect golang.org/x/sys v0.33.0 // indirect golang.org/x/text v0.26.0 // indirect diff --git a/go.sum b/go.sum index 562997d8..a27d1971 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,5 @@ github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b h1:fR+ae4QXF8R4GqKrzEls7WaibF1wjiVvifUl+IoP37I= -github.com/dapr/dapr v1.15.4-0.20250618123356-78343f18338b/go.mod h1:kx/7l7wDGkKRVoE6CUtuNl1FjKA0hj7bn/6xJ1Fc6HY= github.com/dapr/durabletask-go v0.7.2 h1:ssNupibV65/o5HNJRceU6x7D4LSyrGsz6nfMFUcI540= github.com/dapr/durabletask-go v0.7.2/go.mod h1:JhMyDybRUFmmgieGxCPeg9e2cWwtx4LwNXjD+LBtKYk= github.com/dapr/kit v0.15.4 h1:29DezCR22OuZhXX4yPEc+lqcOf/PNaeAuIEx9nGv394= diff --git a/internal/proto/README.md b/internal/proto/README.md new file mode 100644 index 00000000..ca3438cf --- /dev/null +++ b/internal/proto/README.md @@ -0,0 +1,13 @@ +# Dapr Protos + +These are generated protos from the [Dapr](https://github.com/dapr/dapr/tree/master/dapr) repository. + +They are version locked using the [.dapr-proto-ref](../../.dapr-proto-ref) file. + +### Bumping the version of the proto files + +The command `make proto-update` makes it easier to bump the proto files version. + +### Generating protos + +To generate the protos, using the current locked version, use the command `make proto` diff --git a/internal/proto/dapr/proto/common/v1/common.pb.go b/internal/proto/dapr/proto/common/v1/common.pb.go new file mode 100644 index 00000000..0f85d01c --- /dev/null +++ b/internal/proto/dapr/proto/common/v1/common.pb.go @@ -0,0 +1,1050 @@ +// +//Copyright 2021 The Dapr Authors +//Licensed under the Apache License, Version 2.0 (the "License"); +//you may not use this file except in compliance with the License. +//You may obtain a copy of the License at +//http://www.apache.org/licenses/LICENSE-2.0 +//Unless required by applicable law or agreed to in writing, software +//distributed under the License is distributed on an "AS IS" BASIS, +//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//See the License for the specific language governing permissions and +//limitations under the License. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.6 +// protoc (unknown) +// source: dapr/proto/common/v1/common.proto + +package commonv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + durationpb "google.golang.org/protobuf/types/known/durationpb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Type of HTTP 1.1 Methods +// RFC 7231: https://tools.ietf.org/html/rfc7231#page-24 +// RFC 5789: https://datatracker.ietf.org/doc/html/rfc5789 +type HTTPExtension_Verb int32 + +const ( + HTTPExtension_NONE HTTPExtension_Verb = 0 + HTTPExtension_GET HTTPExtension_Verb = 1 + HTTPExtension_HEAD HTTPExtension_Verb = 2 + HTTPExtension_POST HTTPExtension_Verb = 3 + HTTPExtension_PUT HTTPExtension_Verb = 4 + HTTPExtension_DELETE HTTPExtension_Verb = 5 + HTTPExtension_CONNECT HTTPExtension_Verb = 6 + HTTPExtension_OPTIONS HTTPExtension_Verb = 7 + HTTPExtension_TRACE HTTPExtension_Verb = 8 + HTTPExtension_PATCH HTTPExtension_Verb = 9 +) + +// Enum value maps for HTTPExtension_Verb. +var ( + HTTPExtension_Verb_name = map[int32]string{ + 0: "NONE", + 1: "GET", + 2: "HEAD", + 3: "POST", + 4: "PUT", + 5: "DELETE", + 6: "CONNECT", + 7: "OPTIONS", + 8: "TRACE", + 9: "PATCH", + } + HTTPExtension_Verb_value = map[string]int32{ + "NONE": 0, + "GET": 1, + "HEAD": 2, + "POST": 3, + "PUT": 4, + "DELETE": 5, + "CONNECT": 6, + "OPTIONS": 7, + "TRACE": 8, + "PATCH": 9, + } +) + +func (x HTTPExtension_Verb) Enum() *HTTPExtension_Verb { + p := new(HTTPExtension_Verb) + *p = x + return p +} + +func (x HTTPExtension_Verb) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (HTTPExtension_Verb) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_common_v1_common_proto_enumTypes[0].Descriptor() +} + +func (HTTPExtension_Verb) Type() protoreflect.EnumType { + return &file_dapr_proto_common_v1_common_proto_enumTypes[0] +} + +func (x HTTPExtension_Verb) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use HTTPExtension_Verb.Descriptor instead. +func (HTTPExtension_Verb) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{0, 0} +} + +// Enum describing the supported concurrency for state. +type StateOptions_StateConcurrency int32 + +const ( + StateOptions_CONCURRENCY_UNSPECIFIED StateOptions_StateConcurrency = 0 + StateOptions_CONCURRENCY_FIRST_WRITE StateOptions_StateConcurrency = 1 + StateOptions_CONCURRENCY_LAST_WRITE StateOptions_StateConcurrency = 2 +) + +// Enum value maps for StateOptions_StateConcurrency. +var ( + StateOptions_StateConcurrency_name = map[int32]string{ + 0: "CONCURRENCY_UNSPECIFIED", + 1: "CONCURRENCY_FIRST_WRITE", + 2: "CONCURRENCY_LAST_WRITE", + } + StateOptions_StateConcurrency_value = map[string]int32{ + "CONCURRENCY_UNSPECIFIED": 0, + "CONCURRENCY_FIRST_WRITE": 1, + "CONCURRENCY_LAST_WRITE": 2, + } +) + +func (x StateOptions_StateConcurrency) Enum() *StateOptions_StateConcurrency { + p := new(StateOptions_StateConcurrency) + *p = x + return p +} + +func (x StateOptions_StateConcurrency) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (StateOptions_StateConcurrency) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_common_v1_common_proto_enumTypes[1].Descriptor() +} + +func (StateOptions_StateConcurrency) Type() protoreflect.EnumType { + return &file_dapr_proto_common_v1_common_proto_enumTypes[1] +} + +func (x StateOptions_StateConcurrency) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use StateOptions_StateConcurrency.Descriptor instead. +func (StateOptions_StateConcurrency) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6, 0} +} + +// Enum describing the supported consistency for state. +type StateOptions_StateConsistency int32 + +const ( + StateOptions_CONSISTENCY_UNSPECIFIED StateOptions_StateConsistency = 0 + StateOptions_CONSISTENCY_EVENTUAL StateOptions_StateConsistency = 1 + StateOptions_CONSISTENCY_STRONG StateOptions_StateConsistency = 2 +) + +// Enum value maps for StateOptions_StateConsistency. +var ( + StateOptions_StateConsistency_name = map[int32]string{ + 0: "CONSISTENCY_UNSPECIFIED", + 1: "CONSISTENCY_EVENTUAL", + 2: "CONSISTENCY_STRONG", + } + StateOptions_StateConsistency_value = map[string]int32{ + "CONSISTENCY_UNSPECIFIED": 0, + "CONSISTENCY_EVENTUAL": 1, + "CONSISTENCY_STRONG": 2, + } +) + +func (x StateOptions_StateConsistency) Enum() *StateOptions_StateConsistency { + p := new(StateOptions_StateConsistency) + *p = x + return p +} + +func (x StateOptions_StateConsistency) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (StateOptions_StateConsistency) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_common_v1_common_proto_enumTypes[2].Descriptor() +} + +func (StateOptions_StateConsistency) Type() protoreflect.EnumType { + return &file_dapr_proto_common_v1_common_proto_enumTypes[2] +} + +func (x StateOptions_StateConsistency) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use StateOptions_StateConsistency.Descriptor instead. +func (StateOptions_StateConsistency) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6, 1} +} + +// HTTPExtension includes HTTP verb and querystring +// when Dapr runtime delivers HTTP content. +// +// For example, when callers calls http invoke api +// `POST http://localhost:3500/v1.0/invoke//method/?query1=value1&query2=value2` +// +// Dapr runtime will parse POST as a verb and extract querystring to quersytring map. +type HTTPExtension struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. HTTP verb. + Verb HTTPExtension_Verb `protobuf:"varint,1,opt,name=verb,proto3,enum=dapr.proto.common.v1.HTTPExtension_Verb" json:"verb,omitempty"` + // Optional. querystring represents an encoded HTTP url query string in the following format: name=value&name2=value2 + Querystring string `protobuf:"bytes,2,opt,name=querystring,proto3" json:"querystring,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HTTPExtension) Reset() { + *x = HTTPExtension{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HTTPExtension) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HTTPExtension) ProtoMessage() {} + +func (x *HTTPExtension) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HTTPExtension.ProtoReflect.Descriptor instead. +func (*HTTPExtension) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{0} +} + +func (x *HTTPExtension) GetVerb() HTTPExtension_Verb { + if x != nil { + return x.Verb + } + return HTTPExtension_NONE +} + +func (x *HTTPExtension) GetQuerystring() string { + if x != nil { + return x.Querystring + } + return "" +} + +// InvokeRequest is the message to invoke a method with the data. +// This message is used in InvokeService of Dapr gRPC Service and OnInvoke +// of AppCallback gRPC service. +type InvokeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. method is a method name which will be invoked by caller. + Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"` + // Required in unary RPCs. Bytes value or Protobuf message which caller sent. + // Dapr treats Any.value as bytes type if Any.type_url is unset. + Data *anypb.Any `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // The type of data content. + // + // This field is required if data delivers http request body + // Otherwise, this is optional. + ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // HTTP specific fields if request conveys http-compatible request. + // + // This field is required for http-compatible request. Otherwise, + // this field is optional. + HttpExtension *HTTPExtension `protobuf:"bytes,4,opt,name=http_extension,json=httpExtension,proto3" json:"http_extension,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeRequest) Reset() { + *x = InvokeRequest{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeRequest) ProtoMessage() {} + +func (x *InvokeRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeRequest.ProtoReflect.Descriptor instead. +func (*InvokeRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{1} +} + +func (x *InvokeRequest) GetMethod() string { + if x != nil { + return x.Method + } + return "" +} + +func (x *InvokeRequest) GetData() *anypb.Any { + if x != nil { + return x.Data + } + return nil +} + +func (x *InvokeRequest) GetContentType() string { + if x != nil { + return x.ContentType + } + return "" +} + +func (x *InvokeRequest) GetHttpExtension() *HTTPExtension { + if x != nil { + return x.HttpExtension + } + return nil +} + +// InvokeResponse is the response message including data and its content type +// from app callback. +// This message is used in InvokeService of Dapr gRPC Service and OnInvoke +// of AppCallback gRPC service. +type InvokeResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required in unary RPCs. The content body of InvokeService response. + Data *anypb.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // Required. The type of data content. + ContentType string `protobuf:"bytes,2,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeResponse) Reset() { + *x = InvokeResponse{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeResponse) ProtoMessage() {} + +func (x *InvokeResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeResponse.ProtoReflect.Descriptor instead. +func (*InvokeResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{2} +} + +func (x *InvokeResponse) GetData() *anypb.Any { + if x != nil { + return x.Data + } + return nil +} + +func (x *InvokeResponse) GetContentType() string { + if x != nil { + return x.ContentType + } + return "" +} + +// Chunk of data sent in a streaming request or response. +// This is used in requests including InternalInvokeRequestStream. +type StreamPayload struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Data sent in the chunk. + // The amount of data included in each chunk is up to the discretion of the sender, and can be empty. + // Additionally, the amount of data doesn't need to be fixed and subsequent messages can send more, or less, data. + // Receivers must not make assumptions about the number of bytes they'll receive in each chunk. + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // Sequence number. This is a counter that starts from 0 and increments by 1 on each chunk sent. + Seq uint64 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StreamPayload) Reset() { + *x = StreamPayload{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StreamPayload) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StreamPayload) ProtoMessage() {} + +func (x *StreamPayload) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StreamPayload.ProtoReflect.Descriptor instead. +func (*StreamPayload) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{3} +} + +func (x *StreamPayload) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *StreamPayload) GetSeq() uint64 { + if x != nil { + return x.Seq + } + return 0 +} + +// StateItem represents state key, value, and additional options to save state. +type StateItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The state key + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // Required. The state data for key + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // The entity tag which represents the specific version of data. + // The exact ETag format is defined by the corresponding data store. + Etag *Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"` + // The metadata which will be passed to state store component. + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Options for concurrency and consistency to save the state. + Options *StateOptions `protobuf:"bytes,5,opt,name=options,proto3" json:"options,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StateItem) Reset() { + *x = StateItem{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StateItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StateItem) ProtoMessage() {} + +func (x *StateItem) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StateItem.ProtoReflect.Descriptor instead. +func (*StateItem) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{4} +} + +func (x *StateItem) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *StateItem) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +func (x *StateItem) GetEtag() *Etag { + if x != nil { + return x.Etag + } + return nil +} + +func (x *StateItem) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *StateItem) GetOptions() *StateOptions { + if x != nil { + return x.Options + } + return nil +} + +// Etag represents a state item version +type Etag struct { + state protoimpl.MessageState `protogen:"open.v1"` + // value sets the etag value + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Etag) Reset() { + *x = Etag{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Etag) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Etag) ProtoMessage() {} + +func (x *Etag) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Etag.ProtoReflect.Descriptor instead. +func (*Etag) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{5} +} + +func (x *Etag) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +// StateOptions configures concurrency and consistency for state operations +type StateOptions struct { + state protoimpl.MessageState `protogen:"open.v1"` + Concurrency StateOptions_StateConcurrency `protobuf:"varint,1,opt,name=concurrency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConcurrency" json:"concurrency,omitempty"` + Consistency StateOptions_StateConsistency `protobuf:"varint,2,opt,name=consistency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConsistency" json:"consistency,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StateOptions) Reset() { + *x = StateOptions{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StateOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StateOptions) ProtoMessage() {} + +func (x *StateOptions) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StateOptions.ProtoReflect.Descriptor instead. +func (*StateOptions) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6} +} + +func (x *StateOptions) GetConcurrency() StateOptions_StateConcurrency { + if x != nil { + return x.Concurrency + } + return StateOptions_CONCURRENCY_UNSPECIFIED +} + +func (x *StateOptions) GetConsistency() StateOptions_StateConsistency { + if x != nil { + return x.Consistency + } + return StateOptions_CONSISTENCY_UNSPECIFIED +} + +// ConfigurationItem represents all the configuration with its name(key). +type ConfigurationItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The value of configuration item. + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + // Version is response only and cannot be fetched. Store is not expected to keep all versions available + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` + // the metadata which will be passed to/from configuration store component. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConfigurationItem) Reset() { + *x = ConfigurationItem{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConfigurationItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConfigurationItem) ProtoMessage() {} + +func (x *ConfigurationItem) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConfigurationItem.ProtoReflect.Descriptor instead. +func (*ConfigurationItem) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{7} +} + +func (x *ConfigurationItem) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *ConfigurationItem) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *ConfigurationItem) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// JobFailurePolicy defines the policy to apply when a job fails to trigger. +type JobFailurePolicy struct { + state protoimpl.MessageState `protogen:"open.v1"` + // policy is the policy to apply when a job fails to trigger. + // + // Types that are valid to be assigned to Policy: + // + // *JobFailurePolicy_Drop + // *JobFailurePolicy_Constant + Policy isJobFailurePolicy_Policy `protobuf_oneof:"policy"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JobFailurePolicy) Reset() { + *x = JobFailurePolicy{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JobFailurePolicy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JobFailurePolicy) ProtoMessage() {} + +func (x *JobFailurePolicy) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JobFailurePolicy.ProtoReflect.Descriptor instead. +func (*JobFailurePolicy) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{8} +} + +func (x *JobFailurePolicy) GetPolicy() isJobFailurePolicy_Policy { + if x != nil { + return x.Policy + } + return nil +} + +func (x *JobFailurePolicy) GetDrop() *JobFailurePolicyDrop { + if x != nil { + if x, ok := x.Policy.(*JobFailurePolicy_Drop); ok { + return x.Drop + } + } + return nil +} + +func (x *JobFailurePolicy) GetConstant() *JobFailurePolicyConstant { + if x != nil { + if x, ok := x.Policy.(*JobFailurePolicy_Constant); ok { + return x.Constant + } + } + return nil +} + +type isJobFailurePolicy_Policy interface { + isJobFailurePolicy_Policy() +} + +type JobFailurePolicy_Drop struct { + Drop *JobFailurePolicyDrop `protobuf:"bytes,1,opt,name=drop,proto3,oneof"` +} + +type JobFailurePolicy_Constant struct { + Constant *JobFailurePolicyConstant `protobuf:"bytes,2,opt,name=constant,proto3,oneof"` +} + +func (*JobFailurePolicy_Drop) isJobFailurePolicy_Policy() {} + +func (*JobFailurePolicy_Constant) isJobFailurePolicy_Policy() {} + +// JobFailurePolicyDrop is a policy which drops the job tick when the job fails to trigger. +type JobFailurePolicyDrop struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JobFailurePolicyDrop) Reset() { + *x = JobFailurePolicyDrop{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JobFailurePolicyDrop) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JobFailurePolicyDrop) ProtoMessage() {} + +func (x *JobFailurePolicyDrop) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JobFailurePolicyDrop.ProtoReflect.Descriptor instead. +func (*JobFailurePolicyDrop) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{9} +} + +// JobFailurePolicyConstant is a policy which retries the job at a consistent interval when the job fails to trigger. +type JobFailurePolicyConstant struct { + state protoimpl.MessageState `protogen:"open.v1"` + // interval is the constant delay to wait before retrying the job. + Interval *durationpb.Duration `protobuf:"bytes,1,opt,name=interval,proto3" json:"interval,omitempty"` + // max_retries is the optional maximum number of retries to attempt before giving up. + // If unset, the Job will be retried indefinitely. + MaxRetries *uint32 `protobuf:"varint,2,opt,name=max_retries,json=maxRetries,proto3,oneof" json:"max_retries,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JobFailurePolicyConstant) Reset() { + *x = JobFailurePolicyConstant{} + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JobFailurePolicyConstant) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JobFailurePolicyConstant) ProtoMessage() {} + +func (x *JobFailurePolicyConstant) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_common_v1_common_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JobFailurePolicyConstant.ProtoReflect.Descriptor instead. +func (*JobFailurePolicyConstant) Descriptor() ([]byte, []int) { + return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{10} +} + +func (x *JobFailurePolicyConstant) GetInterval() *durationpb.Duration { + if x != nil { + return x.Interval + } + return nil +} + +func (x *JobFailurePolicyConstant) GetMaxRetries() uint32 { + if x != nil && x.MaxRetries != nil { + return *x.MaxRetries + } + return 0 +} + +var File_dapr_proto_common_v1_common_proto protoreflect.FileDescriptor + +const file_dapr_proto_common_v1_common_proto_rawDesc = "" + + "\n" + + "!dapr/proto/common/v1/common.proto\x12\x14dapr.proto.common.v1\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\"\xe3\x01\n" + + "\rHTTPExtension\x12<\n" + + "\x04verb\x18\x01 \x01(\x0e2(.dapr.proto.common.v1.HTTPExtension.VerbR\x04verb\x12 \n" + + "\vquerystring\x18\x02 \x01(\tR\vquerystring\"r\n" + + "\x04Verb\x12\b\n" + + "\x04NONE\x10\x00\x12\a\n" + + "\x03GET\x10\x01\x12\b\n" + + "\x04HEAD\x10\x02\x12\b\n" + + "\x04POST\x10\x03\x12\a\n" + + "\x03PUT\x10\x04\x12\n" + + "\n" + + "\x06DELETE\x10\x05\x12\v\n" + + "\aCONNECT\x10\x06\x12\v\n" + + "\aOPTIONS\x10\a\x12\t\n" + + "\x05TRACE\x10\b\x12\t\n" + + "\x05PATCH\x10\t\"\xc0\x01\n" + + "\rInvokeRequest\x12\x16\n" + + "\x06method\x18\x01 \x01(\tR\x06method\x12(\n" + + "\x04data\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x04data\x12!\n" + + "\fcontent_type\x18\x03 \x01(\tR\vcontentType\x12J\n" + + "\x0ehttp_extension\x18\x04 \x01(\v2#.dapr.proto.common.v1.HTTPExtensionR\rhttpExtension\"]\n" + + "\x0eInvokeResponse\x12(\n" + + "\x04data\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\x04data\x12!\n" + + "\fcontent_type\x18\x02 \x01(\tR\vcontentType\"5\n" + + "\rStreamPayload\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\x12\x10\n" + + "\x03seq\x18\x02 \x01(\x04R\x03seq\"\xa9\x02\n" + + "\tStateItem\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value\x12.\n" + + "\x04etag\x18\x03 \x01(\v2\x1a.dapr.proto.common.v1.EtagR\x04etag\x12I\n" + + "\bmetadata\x18\x04 \x03(\v2-.dapr.proto.common.v1.StateItem.MetadataEntryR\bmetadata\x12<\n" + + "\aoptions\x18\x05 \x01(\v2\".dapr.proto.common.v1.StateOptionsR\aoptions\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x1c\n" + + "\x04Etag\x12\x14\n" + + "\x05value\x18\x01 \x01(\tR\x05value\"\x89\x03\n" + + "\fStateOptions\x12U\n" + + "\vconcurrency\x18\x01 \x01(\x0e23.dapr.proto.common.v1.StateOptions.StateConcurrencyR\vconcurrency\x12U\n" + + "\vconsistency\x18\x02 \x01(\x0e23.dapr.proto.common.v1.StateOptions.StateConsistencyR\vconsistency\"h\n" + + "\x10StateConcurrency\x12\x1b\n" + + "\x17CONCURRENCY_UNSPECIFIED\x10\x00\x12\x1b\n" + + "\x17CONCURRENCY_FIRST_WRITE\x10\x01\x12\x1a\n" + + "\x16CONCURRENCY_LAST_WRITE\x10\x02\"a\n" + + "\x10StateConsistency\x12\x1b\n" + + "\x17CONSISTENCY_UNSPECIFIED\x10\x00\x12\x18\n" + + "\x14CONSISTENCY_EVENTUAL\x10\x01\x12\x16\n" + + "\x12CONSISTENCY_STRONG\x10\x02\"\xd3\x01\n" + + "\x11ConfigurationItem\x12\x14\n" + + "\x05value\x18\x01 \x01(\tR\x05value\x12\x18\n" + + "\aversion\x18\x02 \x01(\tR\aversion\x12Q\n" + + "\bmetadata\x18\x03 \x03(\v25.dapr.proto.common.v1.ConfigurationItem.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xac\x01\n" + + "\x10JobFailurePolicy\x12@\n" + + "\x04drop\x18\x01 \x01(\v2*.dapr.proto.common.v1.JobFailurePolicyDropH\x00R\x04drop\x12L\n" + + "\bconstant\x18\x02 \x01(\v2..dapr.proto.common.v1.JobFailurePolicyConstantH\x00R\bconstantB\b\n" + + "\x06policy\"\x16\n" + + "\x14JobFailurePolicyDrop\"\x87\x01\n" + + "\x18JobFailurePolicyConstant\x125\n" + + "\binterval\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\binterval\x12$\n" + + "\vmax_retries\x18\x02 \x01(\rH\x00R\n" + + "maxRetries\x88\x01\x01B\x0e\n" + + "\f_max_retriesB\xdf\x01\n" + + "\x18com.dapr.proto.common.v1B\vCommonProtoP\x01ZCgithub.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1;commonv1\xa2\x02\x03DPC\xaa\x02\x14Dapr.Proto.Common.V1\xca\x02\x14Dapr\\Proto\\Common\\V1\xe2\x02 Dapr\\Proto\\Common\\V1\\GPBMetadata\xea\x02\x17Dapr::Proto::Common::V1b\x06proto3" + +var ( + file_dapr_proto_common_v1_common_proto_rawDescOnce sync.Once + file_dapr_proto_common_v1_common_proto_rawDescData []byte +) + +func file_dapr_proto_common_v1_common_proto_rawDescGZIP() []byte { + file_dapr_proto_common_v1_common_proto_rawDescOnce.Do(func() { + file_dapr_proto_common_v1_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_dapr_proto_common_v1_common_proto_rawDesc), len(file_dapr_proto_common_v1_common_proto_rawDesc))) + }) + return file_dapr_proto_common_v1_common_proto_rawDescData +} + +var file_dapr_proto_common_v1_common_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_dapr_proto_common_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 13) +var file_dapr_proto_common_v1_common_proto_goTypes = []any{ + (HTTPExtension_Verb)(0), // 0: dapr.proto.common.v1.HTTPExtension.Verb + (StateOptions_StateConcurrency)(0), // 1: dapr.proto.common.v1.StateOptions.StateConcurrency + (StateOptions_StateConsistency)(0), // 2: dapr.proto.common.v1.StateOptions.StateConsistency + (*HTTPExtension)(nil), // 3: dapr.proto.common.v1.HTTPExtension + (*InvokeRequest)(nil), // 4: dapr.proto.common.v1.InvokeRequest + (*InvokeResponse)(nil), // 5: dapr.proto.common.v1.InvokeResponse + (*StreamPayload)(nil), // 6: dapr.proto.common.v1.StreamPayload + (*StateItem)(nil), // 7: dapr.proto.common.v1.StateItem + (*Etag)(nil), // 8: dapr.proto.common.v1.Etag + (*StateOptions)(nil), // 9: dapr.proto.common.v1.StateOptions + (*ConfigurationItem)(nil), // 10: dapr.proto.common.v1.ConfigurationItem + (*JobFailurePolicy)(nil), // 11: dapr.proto.common.v1.JobFailurePolicy + (*JobFailurePolicyDrop)(nil), // 12: dapr.proto.common.v1.JobFailurePolicyDrop + (*JobFailurePolicyConstant)(nil), // 13: dapr.proto.common.v1.JobFailurePolicyConstant + nil, // 14: dapr.proto.common.v1.StateItem.MetadataEntry + nil, // 15: dapr.proto.common.v1.ConfigurationItem.MetadataEntry + (*anypb.Any)(nil), // 16: google.protobuf.Any + (*durationpb.Duration)(nil), // 17: google.protobuf.Duration +} +var file_dapr_proto_common_v1_common_proto_depIdxs = []int32{ + 0, // 0: dapr.proto.common.v1.HTTPExtension.verb:type_name -> dapr.proto.common.v1.HTTPExtension.Verb + 16, // 1: dapr.proto.common.v1.InvokeRequest.data:type_name -> google.protobuf.Any + 3, // 2: dapr.proto.common.v1.InvokeRequest.http_extension:type_name -> dapr.proto.common.v1.HTTPExtension + 16, // 3: dapr.proto.common.v1.InvokeResponse.data:type_name -> google.protobuf.Any + 8, // 4: dapr.proto.common.v1.StateItem.etag:type_name -> dapr.proto.common.v1.Etag + 14, // 5: dapr.proto.common.v1.StateItem.metadata:type_name -> dapr.proto.common.v1.StateItem.MetadataEntry + 9, // 6: dapr.proto.common.v1.StateItem.options:type_name -> dapr.proto.common.v1.StateOptions + 1, // 7: dapr.proto.common.v1.StateOptions.concurrency:type_name -> dapr.proto.common.v1.StateOptions.StateConcurrency + 2, // 8: dapr.proto.common.v1.StateOptions.consistency:type_name -> dapr.proto.common.v1.StateOptions.StateConsistency + 15, // 9: dapr.proto.common.v1.ConfigurationItem.metadata:type_name -> dapr.proto.common.v1.ConfigurationItem.MetadataEntry + 12, // 10: dapr.proto.common.v1.JobFailurePolicy.drop:type_name -> dapr.proto.common.v1.JobFailurePolicyDrop + 13, // 11: dapr.proto.common.v1.JobFailurePolicy.constant:type_name -> dapr.proto.common.v1.JobFailurePolicyConstant + 17, // 12: dapr.proto.common.v1.JobFailurePolicyConstant.interval:type_name -> google.protobuf.Duration + 13, // [13:13] is the sub-list for method output_type + 13, // [13:13] is the sub-list for method input_type + 13, // [13:13] is the sub-list for extension type_name + 13, // [13:13] is the sub-list for extension extendee + 0, // [0:13] is the sub-list for field type_name +} + +func init() { file_dapr_proto_common_v1_common_proto_init() } +func file_dapr_proto_common_v1_common_proto_init() { + if File_dapr_proto_common_v1_common_proto != nil { + return + } + file_dapr_proto_common_v1_common_proto_msgTypes[8].OneofWrappers = []any{ + (*JobFailurePolicy_Drop)(nil), + (*JobFailurePolicy_Constant)(nil), + } + file_dapr_proto_common_v1_common_proto_msgTypes[10].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_dapr_proto_common_v1_common_proto_rawDesc), len(file_dapr_proto_common_v1_common_proto_rawDesc)), + NumEnums: 3, + NumMessages: 13, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_dapr_proto_common_v1_common_proto_goTypes, + DependencyIndexes: file_dapr_proto_common_v1_common_proto_depIdxs, + EnumInfos: file_dapr_proto_common_v1_common_proto_enumTypes, + MessageInfos: file_dapr_proto_common_v1_common_proto_msgTypes, + }.Build() + File_dapr_proto_common_v1_common_proto = out.File + file_dapr_proto_common_v1_common_proto_goTypes = nil + file_dapr_proto_common_v1_common_proto_depIdxs = nil +} diff --git a/internal/proto/dapr/proto/runtime/v1/appcallback.pb.go b/internal/proto/dapr/proto/runtime/v1/appcallback.pb.go new file mode 100644 index 00000000..cf0c4146 --- /dev/null +++ b/internal/proto/dapr/proto/runtime/v1/appcallback.pb.go @@ -0,0 +1,1653 @@ +// +//Copyright 2021 The Dapr Authors +//Licensed under the Apache License, Version 2.0 (the "License"); +//you may not use this file except in compliance with the License. +//You may obtain a copy of the License at +//http://www.apache.org/licenses/LICENSE-2.0 +//Unless required by applicable law or agreed to in writing, software +//distributed under the License is distributed on an "AS IS" BASIS, +//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//See the License for the specific language governing permissions and +//limitations under the License. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.6 +// protoc (unknown) +// source: dapr/proto/runtime/v1/appcallback.proto + +package runtimev1 + +import ( + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + emptypb "google.golang.org/protobuf/types/known/emptypb" + structpb "google.golang.org/protobuf/types/known/structpb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// TopicEventResponseStatus allows apps to have finer control over handling of the message. +type TopicEventResponse_TopicEventResponseStatus int32 + +const ( + // SUCCESS is the default behavior: message is acknowledged and not retried or logged. + TopicEventResponse_SUCCESS TopicEventResponse_TopicEventResponseStatus = 0 + // RETRY status signals Dapr to retry the message as part of an expected scenario (no warning is logged). + TopicEventResponse_RETRY TopicEventResponse_TopicEventResponseStatus = 1 + // DROP status signals Dapr to drop the message as part of an unexpected scenario (warning is logged). + TopicEventResponse_DROP TopicEventResponse_TopicEventResponseStatus = 2 +) + +// Enum value maps for TopicEventResponse_TopicEventResponseStatus. +var ( + TopicEventResponse_TopicEventResponseStatus_name = map[int32]string{ + 0: "SUCCESS", + 1: "RETRY", + 2: "DROP", + } + TopicEventResponse_TopicEventResponseStatus_value = map[string]int32{ + "SUCCESS": 0, + "RETRY": 1, + "DROP": 2, + } +) + +func (x TopicEventResponse_TopicEventResponseStatus) Enum() *TopicEventResponse_TopicEventResponseStatus { + p := new(TopicEventResponse_TopicEventResponseStatus) + *p = x + return p +} + +func (x TopicEventResponse_TopicEventResponseStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TopicEventResponse_TopicEventResponseStatus) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[0].Descriptor() +} + +func (TopicEventResponse_TopicEventResponseStatus) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[0] +} + +func (x TopicEventResponse_TopicEventResponseStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TopicEventResponse_TopicEventResponseStatus.Descriptor instead. +func (TopicEventResponse_TopicEventResponseStatus) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{3, 0} +} + +// BindingEventConcurrency is the kind of concurrency +type BindingEventResponse_BindingEventConcurrency int32 + +const ( + // SEQUENTIAL sends data to output bindings specified in "to" sequentially. + BindingEventResponse_SEQUENTIAL BindingEventResponse_BindingEventConcurrency = 0 + // PARALLEL sends data to output bindings specified in "to" in parallel. + BindingEventResponse_PARALLEL BindingEventResponse_BindingEventConcurrency = 1 +) + +// Enum value maps for BindingEventResponse_BindingEventConcurrency. +var ( + BindingEventResponse_BindingEventConcurrency_name = map[int32]string{ + 0: "SEQUENTIAL", + 1: "PARALLEL", + } + BindingEventResponse_BindingEventConcurrency_value = map[string]int32{ + "SEQUENTIAL": 0, + "PARALLEL": 1, + } +) + +func (x BindingEventResponse_BindingEventConcurrency) Enum() *BindingEventResponse_BindingEventConcurrency { + p := new(BindingEventResponse_BindingEventConcurrency) + *p = x + return p +} + +func (x BindingEventResponse_BindingEventConcurrency) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (BindingEventResponse_BindingEventConcurrency) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[1].Descriptor() +} + +func (BindingEventResponse_BindingEventConcurrency) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[1] +} + +func (x BindingEventResponse_BindingEventConcurrency) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use BindingEventResponse_BindingEventConcurrency.Descriptor instead. +func (BindingEventResponse_BindingEventConcurrency) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{10, 0} +} + +type JobEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Job name. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Job data to be sent back to app. + Data *anypb.Any `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // Required. method is a method name which will be invoked by caller. + Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"` + // The type of data content. + // + // This field is required if data delivers http request body + // Otherwise, this is optional. + ContentType string `protobuf:"bytes,4,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // HTTP specific fields if request conveys http-compatible request. + // + // This field is required for http-compatible request. Otherwise, + // this field is optional. + HttpExtension *v1.HTTPExtension `protobuf:"bytes,5,opt,name=http_extension,json=httpExtension,proto3" json:"http_extension,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JobEventRequest) Reset() { + *x = JobEventRequest{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JobEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JobEventRequest) ProtoMessage() {} + +func (x *JobEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JobEventRequest.ProtoReflect.Descriptor instead. +func (*JobEventRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{0} +} + +func (x *JobEventRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *JobEventRequest) GetData() *anypb.Any { + if x != nil { + return x.Data + } + return nil +} + +func (x *JobEventRequest) GetMethod() string { + if x != nil { + return x.Method + } + return "" +} + +func (x *JobEventRequest) GetContentType() string { + if x != nil { + return x.ContentType + } + return "" +} + +func (x *JobEventRequest) GetHttpExtension() *v1.HTTPExtension { + if x != nil { + return x.HttpExtension + } + return nil +} + +// JobEventResponse is the response from the app when a job is triggered. +type JobEventResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JobEventResponse) Reset() { + *x = JobEventResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JobEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JobEventResponse) ProtoMessage() {} + +func (x *JobEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JobEventResponse.ProtoReflect.Descriptor instead. +func (*JobEventResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{1} +} + +// TopicEventRequest message is compatible with CloudEvent spec v1.0 +// https://github.com/cloudevents/spec/blob/v1.0/spec.md +type TopicEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // id identifies the event. Producers MUST ensure that source + id + // is unique for each distinct event. If a duplicate event is re-sent + // (e.g. due to a network error) it MAY have the same id. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // source identifies the context in which an event happened. + // Often this will include information such as the type of the + // event source, the organization publishing the event or the process + // that produced the event. The exact syntax and semantics behind + // the data encoded in the URI is defined by the event producer. + Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` + // The type of event related to the originating occurrence. + Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` + // The version of the CloudEvents specification. + SpecVersion string `protobuf:"bytes,4,opt,name=spec_version,json=specVersion,proto3" json:"spec_version,omitempty"` + // The content type of data value. + DataContentType string `protobuf:"bytes,5,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"` + // The content of the event. + Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` + // The pubsub topic which publisher sent to. + Topic string `protobuf:"bytes,6,opt,name=topic,proto3" json:"topic,omitempty"` + // The name of the pubsub the publisher sent to. + PubsubName string `protobuf:"bytes,8,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // The matching path from TopicSubscription/routes (if specified) for this event. + // This value is used by OnTopicEvent to "switch" inside the handler. + Path string `protobuf:"bytes,9,opt,name=path,proto3" json:"path,omitempty"` + // The map of additional custom properties to be sent to the app. These are considered to be cloud event extensions. + Extensions *structpb.Struct `protobuf:"bytes,10,opt,name=extensions,proto3" json:"extensions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventRequest) Reset() { + *x = TopicEventRequest{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventRequest) ProtoMessage() {} + +func (x *TopicEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventRequest.ProtoReflect.Descriptor instead. +func (*TopicEventRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{2} +} + +func (x *TopicEventRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TopicEventRequest) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +func (x *TopicEventRequest) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *TopicEventRequest) GetSpecVersion() string { + if x != nil { + return x.SpecVersion + } + return "" +} + +func (x *TopicEventRequest) GetDataContentType() string { + if x != nil { + return x.DataContentType + } + return "" +} + +func (x *TopicEventRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *TopicEventRequest) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *TopicEventRequest) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *TopicEventRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *TopicEventRequest) GetExtensions() *structpb.Struct { + if x != nil { + return x.Extensions + } + return nil +} + +// TopicEventResponse is response from app on published message +type TopicEventResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of output bindings. + Status TopicEventResponse_TopicEventResponseStatus `protobuf:"varint,1,opt,name=status,proto3,enum=dapr.proto.runtime.v1.TopicEventResponse_TopicEventResponseStatus" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventResponse) Reset() { + *x = TopicEventResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventResponse) ProtoMessage() {} + +func (x *TopicEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventResponse.ProtoReflect.Descriptor instead. +func (*TopicEventResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{3} +} + +func (x *TopicEventResponse) GetStatus() TopicEventResponse_TopicEventResponseStatus { + if x != nil { + return x.Status + } + return TopicEventResponse_SUCCESS +} + +// TopicEventCERequest message is compatible with CloudEvent spec v1.0 +type TopicEventCERequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The unique identifier of this cloud event. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // source identifies the context in which an event happened. + Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` + // The type of event related to the originating occurrence. + Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` + // The version of the CloudEvents specification. + SpecVersion string `protobuf:"bytes,4,opt,name=spec_version,json=specVersion,proto3" json:"spec_version,omitempty"` + // The content type of data value. + DataContentType string `protobuf:"bytes,5,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"` + // The content of the event. + Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` + // Custom attributes which includes cloud event extensions. + Extensions *structpb.Struct `protobuf:"bytes,7,opt,name=extensions,proto3" json:"extensions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventCERequest) Reset() { + *x = TopicEventCERequest{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventCERequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventCERequest) ProtoMessage() {} + +func (x *TopicEventCERequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventCERequest.ProtoReflect.Descriptor instead. +func (*TopicEventCERequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{4} +} + +func (x *TopicEventCERequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TopicEventCERequest) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +func (x *TopicEventCERequest) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *TopicEventCERequest) GetSpecVersion() string { + if x != nil { + return x.SpecVersion + } + return "" +} + +func (x *TopicEventCERequest) GetDataContentType() string { + if x != nil { + return x.DataContentType + } + return "" +} + +func (x *TopicEventCERequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *TopicEventCERequest) GetExtensions() *structpb.Struct { + if x != nil { + return x.Extensions + } + return nil +} + +// TopicEventBulkRequestEntry represents a single message inside a bulk request +type TopicEventBulkRequestEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Unique identifier for the message. + EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"` + // The content of the event. + // + // Types that are valid to be assigned to Event: + // + // *TopicEventBulkRequestEntry_Bytes + // *TopicEventBulkRequestEntry_CloudEvent + Event isTopicEventBulkRequestEntry_Event `protobuf_oneof:"event"` + // content type of the event contained. + ContentType string `protobuf:"bytes,4,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // The metadata associated with the event. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventBulkRequestEntry) Reset() { + *x = TopicEventBulkRequestEntry{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventBulkRequestEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventBulkRequestEntry) ProtoMessage() {} + +func (x *TopicEventBulkRequestEntry) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventBulkRequestEntry.ProtoReflect.Descriptor instead. +func (*TopicEventBulkRequestEntry) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{5} +} + +func (x *TopicEventBulkRequestEntry) GetEntryId() string { + if x != nil { + return x.EntryId + } + return "" +} + +func (x *TopicEventBulkRequestEntry) GetEvent() isTopicEventBulkRequestEntry_Event { + if x != nil { + return x.Event + } + return nil +} + +func (x *TopicEventBulkRequestEntry) GetBytes() []byte { + if x != nil { + if x, ok := x.Event.(*TopicEventBulkRequestEntry_Bytes); ok { + return x.Bytes + } + } + return nil +} + +func (x *TopicEventBulkRequestEntry) GetCloudEvent() *TopicEventCERequest { + if x != nil { + if x, ok := x.Event.(*TopicEventBulkRequestEntry_CloudEvent); ok { + return x.CloudEvent + } + } + return nil +} + +func (x *TopicEventBulkRequestEntry) GetContentType() string { + if x != nil { + return x.ContentType + } + return "" +} + +func (x *TopicEventBulkRequestEntry) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +type isTopicEventBulkRequestEntry_Event interface { + isTopicEventBulkRequestEntry_Event() +} + +type TopicEventBulkRequestEntry_Bytes struct { + Bytes []byte `protobuf:"bytes,2,opt,name=bytes,proto3,oneof"` +} + +type TopicEventBulkRequestEntry_CloudEvent struct { + CloudEvent *TopicEventCERequest `protobuf:"bytes,3,opt,name=cloud_event,json=cloudEvent,proto3,oneof"` +} + +func (*TopicEventBulkRequestEntry_Bytes) isTopicEventBulkRequestEntry_Event() {} + +func (*TopicEventBulkRequestEntry_CloudEvent) isTopicEventBulkRequestEntry_Event() {} + +// TopicEventBulkRequest represents request for bulk message +type TopicEventBulkRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Unique identifier for the bulk request. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // The list of items inside this bulk request. + Entries []*TopicEventBulkRequestEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"` + // The metadata associated with the this bulk request. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The pubsub topic which publisher sent to. + Topic string `protobuf:"bytes,4,opt,name=topic,proto3" json:"topic,omitempty"` + // The name of the pubsub the publisher sent to. + PubsubName string `protobuf:"bytes,5,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // The type of event related to the originating occurrence. + Type string `protobuf:"bytes,6,opt,name=type,proto3" json:"type,omitempty"` + // The matching path from TopicSubscription/routes (if specified) for this event. + // This value is used by OnTopicEvent to "switch" inside the handler. + Path string `protobuf:"bytes,7,opt,name=path,proto3" json:"path,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventBulkRequest) Reset() { + *x = TopicEventBulkRequest{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventBulkRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventBulkRequest) ProtoMessage() {} + +func (x *TopicEventBulkRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventBulkRequest.ProtoReflect.Descriptor instead. +func (*TopicEventBulkRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{6} +} + +func (x *TopicEventBulkRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TopicEventBulkRequest) GetEntries() []*TopicEventBulkRequestEntry { + if x != nil { + return x.Entries + } + return nil +} + +func (x *TopicEventBulkRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TopicEventBulkRequest) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *TopicEventBulkRequest) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *TopicEventBulkRequest) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *TopicEventBulkRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +// TopicEventBulkResponseEntry Represents single response, as part of TopicEventBulkResponse, to be +// sent by subscibed App for the corresponding single message during bulk subscribe +type TopicEventBulkResponseEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Unique identifier associated the message. + EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"` + // The status of the response. + Status TopicEventResponse_TopicEventResponseStatus `protobuf:"varint,2,opt,name=status,proto3,enum=dapr.proto.runtime.v1.TopicEventResponse_TopicEventResponseStatus" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventBulkResponseEntry) Reset() { + *x = TopicEventBulkResponseEntry{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventBulkResponseEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventBulkResponseEntry) ProtoMessage() {} + +func (x *TopicEventBulkResponseEntry) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventBulkResponseEntry.ProtoReflect.Descriptor instead. +func (*TopicEventBulkResponseEntry) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{7} +} + +func (x *TopicEventBulkResponseEntry) GetEntryId() string { + if x != nil { + return x.EntryId + } + return "" +} + +func (x *TopicEventBulkResponseEntry) GetStatus() TopicEventResponse_TopicEventResponseStatus { + if x != nil { + return x.Status + } + return TopicEventResponse_SUCCESS +} + +// AppBulkResponse is response from app on published message +type TopicEventBulkResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of all responses for the bulk request. + Statuses []*TopicEventBulkResponseEntry `protobuf:"bytes,1,rep,name=statuses,proto3" json:"statuses,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicEventBulkResponse) Reset() { + *x = TopicEventBulkResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicEventBulkResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicEventBulkResponse) ProtoMessage() {} + +func (x *TopicEventBulkResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicEventBulkResponse.ProtoReflect.Descriptor instead. +func (*TopicEventBulkResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{8} +} + +func (x *TopicEventBulkResponse) GetStatuses() []*TopicEventBulkResponseEntry { + if x != nil { + return x.Statuses + } + return nil +} + +// BindingEventRequest represents input bindings event. +type BindingEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The name of the input binding component. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Required. The payload that the input bindings sent + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // The metadata set by the input binging components. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BindingEventRequest) Reset() { + *x = BindingEventRequest{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BindingEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BindingEventRequest) ProtoMessage() {} + +func (x *BindingEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BindingEventRequest.ProtoReflect.Descriptor instead. +func (*BindingEventRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{9} +} + +func (x *BindingEventRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *BindingEventRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *BindingEventRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// BindingEventResponse includes operations to save state or +// send data to output bindings optionally. +type BindingEventResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store where states are saved. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The state key values which will be stored in store_name. + States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"` + // The list of output bindings. + To []string `protobuf:"bytes,3,rep,name=to,proto3" json:"to,omitempty"` + // The content which will be sent to "to" output bindings. + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + // The concurrency of output bindings to send data to + // "to" output bindings list. The default is SEQUENTIAL. + Concurrency BindingEventResponse_BindingEventConcurrency `protobuf:"varint,5,opt,name=concurrency,proto3,enum=dapr.proto.runtime.v1.BindingEventResponse_BindingEventConcurrency" json:"concurrency,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BindingEventResponse) Reset() { + *x = BindingEventResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BindingEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BindingEventResponse) ProtoMessage() {} + +func (x *BindingEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BindingEventResponse.ProtoReflect.Descriptor instead. +func (*BindingEventResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{10} +} + +func (x *BindingEventResponse) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *BindingEventResponse) GetStates() []*v1.StateItem { + if x != nil { + return x.States + } + return nil +} + +func (x *BindingEventResponse) GetTo() []string { + if x != nil { + return x.To + } + return nil +} + +func (x *BindingEventResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *BindingEventResponse) GetConcurrency() BindingEventResponse_BindingEventConcurrency { + if x != nil { + return x.Concurrency + } + return BindingEventResponse_SEQUENTIAL +} + +// ListTopicSubscriptionsResponse is the message including the list of the subscribing topics. +type ListTopicSubscriptionsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of topics. + Subscriptions []*TopicSubscription `protobuf:"bytes,1,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListTopicSubscriptionsResponse) Reset() { + *x = ListTopicSubscriptionsResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListTopicSubscriptionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListTopicSubscriptionsResponse) ProtoMessage() {} + +func (x *ListTopicSubscriptionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListTopicSubscriptionsResponse.ProtoReflect.Descriptor instead. +func (*ListTopicSubscriptionsResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{11} +} + +func (x *ListTopicSubscriptionsResponse) GetSubscriptions() []*TopicSubscription { + if x != nil { + return x.Subscriptions + } + return nil +} + +// TopicSubscription represents topic and metadata. +type TopicSubscription struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The name of the pubsub containing the topic below to subscribe to. + PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // Required. The name of topic which will be subscribed + Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"` + // The optional properties used for this topic's subscription e.g. session id + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The optional routing rules to match against. In the gRPC interface, OnTopicEvent + // is still invoked but the matching path is sent in the TopicEventRequest. + Routes *TopicRoutes `protobuf:"bytes,5,opt,name=routes,proto3" json:"routes,omitempty"` + // The optional dead letter queue for this topic to send events to. + DeadLetterTopic string `protobuf:"bytes,6,opt,name=dead_letter_topic,json=deadLetterTopic,proto3" json:"dead_letter_topic,omitempty"` + // The optional bulk subscribe settings for this topic. + BulkSubscribe *BulkSubscribeConfig `protobuf:"bytes,7,opt,name=bulk_subscribe,json=bulkSubscribe,proto3" json:"bulk_subscribe,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicSubscription) Reset() { + *x = TopicSubscription{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicSubscription) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicSubscription) ProtoMessage() {} + +func (x *TopicSubscription) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicSubscription.ProtoReflect.Descriptor instead. +func (*TopicSubscription) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{12} +} + +func (x *TopicSubscription) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *TopicSubscription) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *TopicSubscription) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *TopicSubscription) GetRoutes() *TopicRoutes { + if x != nil { + return x.Routes + } + return nil +} + +func (x *TopicSubscription) GetDeadLetterTopic() string { + if x != nil { + return x.DeadLetterTopic + } + return "" +} + +func (x *TopicSubscription) GetBulkSubscribe() *BulkSubscribeConfig { + if x != nil { + return x.BulkSubscribe + } + return nil +} + +type TopicRoutes struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of rules for this topic. + Rules []*TopicRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"` + // The default path for this topic. + Default string `protobuf:"bytes,2,opt,name=default,proto3" json:"default,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicRoutes) Reset() { + *x = TopicRoutes{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicRoutes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicRoutes) ProtoMessage() {} + +func (x *TopicRoutes) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicRoutes.ProtoReflect.Descriptor instead. +func (*TopicRoutes) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{13} +} + +func (x *TopicRoutes) GetRules() []*TopicRule { + if x != nil { + return x.Rules + } + return nil +} + +func (x *TopicRoutes) GetDefault() string { + if x != nil { + return x.Default + } + return "" +} + +type TopicRule struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The optional CEL expression used to match the event. + // If the match is not specified, then the route is considered + // the default. + Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"` + // The path used to identify matches for this subscription. + // This value is passed in TopicEventRequest and used by OnTopicEvent to "switch" + // inside the handler. + Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TopicRule) Reset() { + *x = TopicRule{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TopicRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TopicRule) ProtoMessage() {} + +func (x *TopicRule) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TopicRule.ProtoReflect.Descriptor instead. +func (*TopicRule) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{14} +} + +func (x *TopicRule) GetMatch() string { + if x != nil { + return x.Match + } + return "" +} + +func (x *TopicRule) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +// BulkSubscribeConfig is the message to pass settings for bulk subscribe +type BulkSubscribeConfig struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. Flag to enable/disable bulk subscribe + Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"` + // Optional. Max number of messages to be sent in a single bulk request + MaxMessagesCount int32 `protobuf:"varint,2,opt,name=max_messages_count,json=maxMessagesCount,proto3" json:"max_messages_count,omitempty"` + // Optional. Max duration to wait for messages to be sent in a single bulk request + MaxAwaitDurationMs int32 `protobuf:"varint,3,opt,name=max_await_duration_ms,json=maxAwaitDurationMs,proto3" json:"max_await_duration_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkSubscribeConfig) Reset() { + *x = BulkSubscribeConfig{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkSubscribeConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkSubscribeConfig) ProtoMessage() {} + +func (x *BulkSubscribeConfig) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkSubscribeConfig.ProtoReflect.Descriptor instead. +func (*BulkSubscribeConfig) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{15} +} + +func (x *BulkSubscribeConfig) GetEnabled() bool { + if x != nil { + return x.Enabled + } + return false +} + +func (x *BulkSubscribeConfig) GetMaxMessagesCount() int32 { + if x != nil { + return x.MaxMessagesCount + } + return 0 +} + +func (x *BulkSubscribeConfig) GetMaxAwaitDurationMs() int32 { + if x != nil { + return x.MaxAwaitDurationMs + } + return 0 +} + +// ListInputBindingsResponse is the message including the list of input bindings. +type ListInputBindingsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of input bindings. + Bindings []string `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListInputBindingsResponse) Reset() { + *x = ListInputBindingsResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListInputBindingsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListInputBindingsResponse) ProtoMessage() {} + +func (x *ListInputBindingsResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListInputBindingsResponse.ProtoReflect.Descriptor instead. +func (*ListInputBindingsResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{16} +} + +func (x *ListInputBindingsResponse) GetBindings() []string { + if x != nil { + return x.Bindings + } + return nil +} + +// HealthCheckResponse is the message with the response to the health check. +// This message is currently empty as used as placeholder. +type HealthCheckResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HealthCheckResponse) Reset() { + *x = HealthCheckResponse{} + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HealthCheckResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HealthCheckResponse) ProtoMessage() {} + +func (x *HealthCheckResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HealthCheckResponse.ProtoReflect.Descriptor instead. +func (*HealthCheckResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{17} +} + +var File_dapr_proto_runtime_v1_appcallback_proto protoreflect.FileDescriptor + +const file_dapr_proto_runtime_v1_appcallback_proto_rawDesc = "" + + "\n" + + "'dapr/proto/runtime/v1/appcallback.proto\x12\x15dapr.proto.runtime.v1\x1a\x19google/protobuf/any.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a!dapr/proto/common/v1/common.proto\x1a\x1cgoogle/protobuf/struct.proto\"\xd6\x01\n" + + "\x0fJobEventRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12(\n" + + "\x04data\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x04data\x12\x16\n" + + "\x06method\x18\x03 \x01(\tR\x06method\x12!\n" + + "\fcontent_type\x18\x04 \x01(\tR\vcontentType\x12J\n" + + "\x0ehttp_extension\x18\x05 \x01(\v2#.dapr.proto.common.v1.HTTPExtensionR\rhttpExtension\"\x12\n" + + "\x10JobEventResponse\"\xb6\x02\n" + + "\x11TopicEventRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x16\n" + + "\x06source\x18\x02 \x01(\tR\x06source\x12\x12\n" + + "\x04type\x18\x03 \x01(\tR\x04type\x12!\n" + + "\fspec_version\x18\x04 \x01(\tR\vspecVersion\x12*\n" + + "\x11data_content_type\x18\x05 \x01(\tR\x0fdataContentType\x12\x12\n" + + "\x04data\x18\a \x01(\fR\x04data\x12\x14\n" + + "\x05topic\x18\x06 \x01(\tR\x05topic\x12\x1f\n" + + "\vpubsub_name\x18\b \x01(\tR\n" + + "pubsubName\x12\x12\n" + + "\x04path\x18\t \x01(\tR\x04path\x127\n" + + "\n" + + "extensions\x18\n" + + " \x01(\v2\x17.google.protobuf.StructR\n" + + "extensions\"\xae\x01\n" + + "\x12TopicEventResponse\x12Z\n" + + "\x06status\x18\x01 \x01(\x0e2B.dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatusR\x06status\"<\n" + + "\x18TopicEventResponseStatus\x12\v\n" + + "\aSUCCESS\x10\x00\x12\t\n" + + "\x05RETRY\x10\x01\x12\b\n" + + "\x04DROP\x10\x02\"\xed\x01\n" + + "\x13TopicEventCERequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x16\n" + + "\x06source\x18\x02 \x01(\tR\x06source\x12\x12\n" + + "\x04type\x18\x03 \x01(\tR\x04type\x12!\n" + + "\fspec_version\x18\x04 \x01(\tR\vspecVersion\x12*\n" + + "\x11data_content_type\x18\x05 \x01(\tR\x0fdataContentType\x12\x12\n" + + "\x04data\x18\x06 \x01(\fR\x04data\x127\n" + + "\n" + + "extensions\x18\a \x01(\v2\x17.google.protobuf.StructR\n" + + "extensions\"\xe4\x02\n" + + "\x1aTopicEventBulkRequestEntry\x12\x19\n" + + "\bentry_id\x18\x01 \x01(\tR\aentryId\x12\x16\n" + + "\x05bytes\x18\x02 \x01(\fH\x00R\x05bytes\x12M\n" + + "\vcloud_event\x18\x03 \x01(\v2*.dapr.proto.runtime.v1.TopicEventCERequestH\x00R\n" + + "cloudEvent\x12!\n" + + "\fcontent_type\x18\x04 \x01(\tR\vcontentType\x12[\n" + + "\bmetadata\x18\x05 \x03(\v2?.dapr.proto.runtime.v1.TopicEventBulkRequestEntry.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\a\n" + + "\x05event\"\xe8\x02\n" + + "\x15TopicEventBulkRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12K\n" + + "\aentries\x18\x02 \x03(\v21.dapr.proto.runtime.v1.TopicEventBulkRequestEntryR\aentries\x12V\n" + + "\bmetadata\x18\x03 \x03(\v2:.dapr.proto.runtime.v1.TopicEventBulkRequest.MetadataEntryR\bmetadata\x12\x14\n" + + "\x05topic\x18\x04 \x01(\tR\x05topic\x12\x1f\n" + + "\vpubsub_name\x18\x05 \x01(\tR\n" + + "pubsubName\x12\x12\n" + + "\x04type\x18\x06 \x01(\tR\x04type\x12\x12\n" + + "\x04path\x18\a \x01(\tR\x04path\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x94\x01\n" + + "\x1bTopicEventBulkResponseEntry\x12\x19\n" + + "\bentry_id\x18\x01 \x01(\tR\aentryId\x12Z\n" + + "\x06status\x18\x02 \x01(\x0e2B.dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatusR\x06status\"h\n" + + "\x16TopicEventBulkResponse\x12N\n" + + "\bstatuses\x18\x01 \x03(\v22.dapr.proto.runtime.v1.TopicEventBulkResponseEntryR\bstatuses\"\xd0\x01\n" + + "\x13BindingEventRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" + + "\x04data\x18\x02 \x01(\fR\x04data\x12T\n" + + "\bmetadata\x18\x03 \x03(\v28.dapr.proto.runtime.v1.BindingEventRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xb2\x02\n" + + "\x14BindingEventResponse\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x127\n" + + "\x06states\x18\x02 \x03(\v2\x1f.dapr.proto.common.v1.StateItemR\x06states\x12\x0e\n" + + "\x02to\x18\x03 \x03(\tR\x02to\x12\x12\n" + + "\x04data\x18\x04 \x01(\fR\x04data\x12e\n" + + "\vconcurrency\x18\x05 \x01(\x0e2C.dapr.proto.runtime.v1.BindingEventResponse.BindingEventConcurrencyR\vconcurrency\"7\n" + + "\x17BindingEventConcurrency\x12\x0e\n" + + "\n" + + "SEQUENTIAL\x10\x00\x12\f\n" + + "\bPARALLEL\x10\x01\"p\n" + + "\x1eListTopicSubscriptionsResponse\x12N\n" + + "\rsubscriptions\x18\x01 \x03(\v2(.dapr.proto.runtime.v1.TopicSubscriptionR\rsubscriptions\"\x96\x03\n" + + "\x11TopicSubscription\x12\x1f\n" + + "\vpubsub_name\x18\x01 \x01(\tR\n" + + "pubsubName\x12\x14\n" + + "\x05topic\x18\x02 \x01(\tR\x05topic\x12R\n" + + "\bmetadata\x18\x03 \x03(\v26.dapr.proto.runtime.v1.TopicSubscription.MetadataEntryR\bmetadata\x12:\n" + + "\x06routes\x18\x05 \x01(\v2\".dapr.proto.runtime.v1.TopicRoutesR\x06routes\x12*\n" + + "\x11dead_letter_topic\x18\x06 \x01(\tR\x0fdeadLetterTopic\x12Q\n" + + "\x0ebulk_subscribe\x18\a \x01(\v2*.dapr.proto.runtime.v1.BulkSubscribeConfigR\rbulkSubscribe\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"_\n" + + "\vTopicRoutes\x126\n" + + "\x05rules\x18\x01 \x03(\v2 .dapr.proto.runtime.v1.TopicRuleR\x05rules\x12\x18\n" + + "\adefault\x18\x02 \x01(\tR\adefault\"5\n" + + "\tTopicRule\x12\x14\n" + + "\x05match\x18\x01 \x01(\tR\x05match\x12\x12\n" + + "\x04path\x18\x02 \x01(\tR\x04path\"\x90\x01\n" + + "\x13BulkSubscribeConfig\x12\x18\n" + + "\aenabled\x18\x01 \x01(\bR\aenabled\x12,\n" + + "\x12max_messages_count\x18\x02 \x01(\x05R\x10maxMessagesCount\x121\n" + + "\x15max_await_duration_ms\x18\x03 \x01(\x05R\x12maxAwaitDurationMs\"7\n" + + "\x19ListInputBindingsResponse\x12\x1a\n" + + "\bbindings\x18\x01 \x03(\tR\bbindings\"\x15\n" + + "\x13HealthCheckResponse2\x86\x04\n" + + "\vAppCallback\x12W\n" + + "\bOnInvoke\x12#.dapr.proto.common.v1.InvokeRequest\x1a$.dapr.proto.common.v1.InvokeResponse\"\x00\x12i\n" + + "\x16ListTopicSubscriptions\x12\x16.google.protobuf.Empty\x1a5.dapr.proto.runtime.v1.ListTopicSubscriptionsResponse\"\x00\x12e\n" + + "\fOnTopicEvent\x12(.dapr.proto.runtime.v1.TopicEventRequest\x1a).dapr.proto.runtime.v1.TopicEventResponse\"\x00\x12_\n" + + "\x11ListInputBindings\x12\x16.google.protobuf.Empty\x1a0.dapr.proto.runtime.v1.ListInputBindingsResponse\"\x00\x12k\n" + + "\x0eOnBindingEvent\x12*.dapr.proto.runtime.v1.BindingEventRequest\x1a+.dapr.proto.runtime.v1.BindingEventResponse\"\x002m\n" + + "\x16AppCallbackHealthCheck\x12S\n" + + "\vHealthCheck\x12\x16.google.protobuf.Empty\x1a*.dapr.proto.runtime.v1.HealthCheckResponse\"\x002\xf0\x01\n" + + "\x10AppCallbackAlpha\x12w\n" + + "\x16OnBulkTopicEventAlpha1\x12,.dapr.proto.runtime.v1.TopicEventBulkRequest\x1a-.dapr.proto.runtime.v1.TopicEventBulkResponse\"\x00\x12c\n" + + "\x10OnJobEventAlpha1\x12&.dapr.proto.runtime.v1.JobEventRequest\x1a'.dapr.proto.runtime.v1.JobEventResponseB\xeb\x01\n" + + "\x19com.dapr.proto.runtime.v1B\x10AppcallbackProtoP\x01ZEgithub.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1;runtimev1\xa2\x02\x03DPR\xaa\x02\x15Dapr.Proto.Runtime.V1\xca\x02\x15Dapr\\Proto\\Runtime\\V1\xe2\x02!Dapr\\Proto\\Runtime\\V1\\GPBMetadata\xea\x02\x18Dapr::Proto::Runtime::V1b\x06proto3" + +var ( + file_dapr_proto_runtime_v1_appcallback_proto_rawDescOnce sync.Once + file_dapr_proto_runtime_v1_appcallback_proto_rawDescData []byte +) + +func file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP() []byte { + file_dapr_proto_runtime_v1_appcallback_proto_rawDescOnce.Do(func() { + file_dapr_proto_runtime_v1_appcallback_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_dapr_proto_runtime_v1_appcallback_proto_rawDesc), len(file_dapr_proto_runtime_v1_appcallback_proto_rawDesc))) + }) + return file_dapr_proto_runtime_v1_appcallback_proto_rawDescData +} + +var file_dapr_proto_runtime_v1_appcallback_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_dapr_proto_runtime_v1_appcallback_proto_msgTypes = make([]protoimpl.MessageInfo, 22) +var file_dapr_proto_runtime_v1_appcallback_proto_goTypes = []any{ + (TopicEventResponse_TopicEventResponseStatus)(0), // 0: dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus + (BindingEventResponse_BindingEventConcurrency)(0), // 1: dapr.proto.runtime.v1.BindingEventResponse.BindingEventConcurrency + (*JobEventRequest)(nil), // 2: dapr.proto.runtime.v1.JobEventRequest + (*JobEventResponse)(nil), // 3: dapr.proto.runtime.v1.JobEventResponse + (*TopicEventRequest)(nil), // 4: dapr.proto.runtime.v1.TopicEventRequest + (*TopicEventResponse)(nil), // 5: dapr.proto.runtime.v1.TopicEventResponse + (*TopicEventCERequest)(nil), // 6: dapr.proto.runtime.v1.TopicEventCERequest + (*TopicEventBulkRequestEntry)(nil), // 7: dapr.proto.runtime.v1.TopicEventBulkRequestEntry + (*TopicEventBulkRequest)(nil), // 8: dapr.proto.runtime.v1.TopicEventBulkRequest + (*TopicEventBulkResponseEntry)(nil), // 9: dapr.proto.runtime.v1.TopicEventBulkResponseEntry + (*TopicEventBulkResponse)(nil), // 10: dapr.proto.runtime.v1.TopicEventBulkResponse + (*BindingEventRequest)(nil), // 11: dapr.proto.runtime.v1.BindingEventRequest + (*BindingEventResponse)(nil), // 12: dapr.proto.runtime.v1.BindingEventResponse + (*ListTopicSubscriptionsResponse)(nil), // 13: dapr.proto.runtime.v1.ListTopicSubscriptionsResponse + (*TopicSubscription)(nil), // 14: dapr.proto.runtime.v1.TopicSubscription + (*TopicRoutes)(nil), // 15: dapr.proto.runtime.v1.TopicRoutes + (*TopicRule)(nil), // 16: dapr.proto.runtime.v1.TopicRule + (*BulkSubscribeConfig)(nil), // 17: dapr.proto.runtime.v1.BulkSubscribeConfig + (*ListInputBindingsResponse)(nil), // 18: dapr.proto.runtime.v1.ListInputBindingsResponse + (*HealthCheckResponse)(nil), // 19: dapr.proto.runtime.v1.HealthCheckResponse + nil, // 20: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.MetadataEntry + nil, // 21: dapr.proto.runtime.v1.TopicEventBulkRequest.MetadataEntry + nil, // 22: dapr.proto.runtime.v1.BindingEventRequest.MetadataEntry + nil, // 23: dapr.proto.runtime.v1.TopicSubscription.MetadataEntry + (*anypb.Any)(nil), // 24: google.protobuf.Any + (*v1.HTTPExtension)(nil), // 25: dapr.proto.common.v1.HTTPExtension + (*structpb.Struct)(nil), // 26: google.protobuf.Struct + (*v1.StateItem)(nil), // 27: dapr.proto.common.v1.StateItem + (*v1.InvokeRequest)(nil), // 28: dapr.proto.common.v1.InvokeRequest + (*emptypb.Empty)(nil), // 29: google.protobuf.Empty + (*v1.InvokeResponse)(nil), // 30: dapr.proto.common.v1.InvokeResponse +} +var file_dapr_proto_runtime_v1_appcallback_proto_depIdxs = []int32{ + 24, // 0: dapr.proto.runtime.v1.JobEventRequest.data:type_name -> google.protobuf.Any + 25, // 1: dapr.proto.runtime.v1.JobEventRequest.http_extension:type_name -> dapr.proto.common.v1.HTTPExtension + 26, // 2: dapr.proto.runtime.v1.TopicEventRequest.extensions:type_name -> google.protobuf.Struct + 0, // 3: dapr.proto.runtime.v1.TopicEventResponse.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus + 26, // 4: dapr.proto.runtime.v1.TopicEventCERequest.extensions:type_name -> google.protobuf.Struct + 6, // 5: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.cloud_event:type_name -> dapr.proto.runtime.v1.TopicEventCERequest + 20, // 6: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.metadata:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequestEntry.MetadataEntry + 7, // 7: dapr.proto.runtime.v1.TopicEventBulkRequest.entries:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequestEntry + 21, // 8: dapr.proto.runtime.v1.TopicEventBulkRequest.metadata:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequest.MetadataEntry + 0, // 9: dapr.proto.runtime.v1.TopicEventBulkResponseEntry.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus + 9, // 10: dapr.proto.runtime.v1.TopicEventBulkResponse.statuses:type_name -> dapr.proto.runtime.v1.TopicEventBulkResponseEntry + 22, // 11: dapr.proto.runtime.v1.BindingEventRequest.metadata:type_name -> dapr.proto.runtime.v1.BindingEventRequest.MetadataEntry + 27, // 12: dapr.proto.runtime.v1.BindingEventResponse.states:type_name -> dapr.proto.common.v1.StateItem + 1, // 13: dapr.proto.runtime.v1.BindingEventResponse.concurrency:type_name -> dapr.proto.runtime.v1.BindingEventResponse.BindingEventConcurrency + 14, // 14: dapr.proto.runtime.v1.ListTopicSubscriptionsResponse.subscriptions:type_name -> dapr.proto.runtime.v1.TopicSubscription + 23, // 15: dapr.proto.runtime.v1.TopicSubscription.metadata:type_name -> dapr.proto.runtime.v1.TopicSubscription.MetadataEntry + 15, // 16: dapr.proto.runtime.v1.TopicSubscription.routes:type_name -> dapr.proto.runtime.v1.TopicRoutes + 17, // 17: dapr.proto.runtime.v1.TopicSubscription.bulk_subscribe:type_name -> dapr.proto.runtime.v1.BulkSubscribeConfig + 16, // 18: dapr.proto.runtime.v1.TopicRoutes.rules:type_name -> dapr.proto.runtime.v1.TopicRule + 28, // 19: dapr.proto.runtime.v1.AppCallback.OnInvoke:input_type -> dapr.proto.common.v1.InvokeRequest + 29, // 20: dapr.proto.runtime.v1.AppCallback.ListTopicSubscriptions:input_type -> google.protobuf.Empty + 4, // 21: dapr.proto.runtime.v1.AppCallback.OnTopicEvent:input_type -> dapr.proto.runtime.v1.TopicEventRequest + 29, // 22: dapr.proto.runtime.v1.AppCallback.ListInputBindings:input_type -> google.protobuf.Empty + 11, // 23: dapr.proto.runtime.v1.AppCallback.OnBindingEvent:input_type -> dapr.proto.runtime.v1.BindingEventRequest + 29, // 24: dapr.proto.runtime.v1.AppCallbackHealthCheck.HealthCheck:input_type -> google.protobuf.Empty + 8, // 25: dapr.proto.runtime.v1.AppCallbackAlpha.OnBulkTopicEventAlpha1:input_type -> dapr.proto.runtime.v1.TopicEventBulkRequest + 2, // 26: dapr.proto.runtime.v1.AppCallbackAlpha.OnJobEventAlpha1:input_type -> dapr.proto.runtime.v1.JobEventRequest + 30, // 27: dapr.proto.runtime.v1.AppCallback.OnInvoke:output_type -> dapr.proto.common.v1.InvokeResponse + 13, // 28: dapr.proto.runtime.v1.AppCallback.ListTopicSubscriptions:output_type -> dapr.proto.runtime.v1.ListTopicSubscriptionsResponse + 5, // 29: dapr.proto.runtime.v1.AppCallback.OnTopicEvent:output_type -> dapr.proto.runtime.v1.TopicEventResponse + 18, // 30: dapr.proto.runtime.v1.AppCallback.ListInputBindings:output_type -> dapr.proto.runtime.v1.ListInputBindingsResponse + 12, // 31: dapr.proto.runtime.v1.AppCallback.OnBindingEvent:output_type -> dapr.proto.runtime.v1.BindingEventResponse + 19, // 32: dapr.proto.runtime.v1.AppCallbackHealthCheck.HealthCheck:output_type -> dapr.proto.runtime.v1.HealthCheckResponse + 10, // 33: dapr.proto.runtime.v1.AppCallbackAlpha.OnBulkTopicEventAlpha1:output_type -> dapr.proto.runtime.v1.TopicEventBulkResponse + 3, // 34: dapr.proto.runtime.v1.AppCallbackAlpha.OnJobEventAlpha1:output_type -> dapr.proto.runtime.v1.JobEventResponse + 27, // [27:35] is the sub-list for method output_type + 19, // [19:27] is the sub-list for method input_type + 19, // [19:19] is the sub-list for extension type_name + 19, // [19:19] is the sub-list for extension extendee + 0, // [0:19] is the sub-list for field type_name +} + +func init() { file_dapr_proto_runtime_v1_appcallback_proto_init() } +func file_dapr_proto_runtime_v1_appcallback_proto_init() { + if File_dapr_proto_runtime_v1_appcallback_proto != nil { + return + } + file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5].OneofWrappers = []any{ + (*TopicEventBulkRequestEntry_Bytes)(nil), + (*TopicEventBulkRequestEntry_CloudEvent)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_dapr_proto_runtime_v1_appcallback_proto_rawDesc), len(file_dapr_proto_runtime_v1_appcallback_proto_rawDesc)), + NumEnums: 2, + NumMessages: 22, + NumExtensions: 0, + NumServices: 3, + }, + GoTypes: file_dapr_proto_runtime_v1_appcallback_proto_goTypes, + DependencyIndexes: file_dapr_proto_runtime_v1_appcallback_proto_depIdxs, + EnumInfos: file_dapr_proto_runtime_v1_appcallback_proto_enumTypes, + MessageInfos: file_dapr_proto_runtime_v1_appcallback_proto_msgTypes, + }.Build() + File_dapr_proto_runtime_v1_appcallback_proto = out.File + file_dapr_proto_runtime_v1_appcallback_proto_goTypes = nil + file_dapr_proto_runtime_v1_appcallback_proto_depIdxs = nil +} diff --git a/internal/proto/dapr/proto/runtime/v1/appcallback_grpc.pb.go b/internal/proto/dapr/proto/runtime/v1/appcallback_grpc.pb.go new file mode 100644 index 00000000..1a098140 --- /dev/null +++ b/internal/proto/dapr/proto/runtime/v1/appcallback_grpc.pb.go @@ -0,0 +1,572 @@ +// +//Copyright 2021 The Dapr Authors +//Licensed under the Apache License, Version 2.0 (the "License"); +//you may not use this file except in compliance with the License. +//You may obtain a copy of the License at +//http://www.apache.org/licenses/LICENSE-2.0 +//Unless required by applicable law or agreed to in writing, software +//distributed under the License is distributed on an "AS IS" BASIS, +//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//See the License for the specific language governing permissions and +//limitations under the License. + +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc (unknown) +// source: dapr/proto/runtime/v1/appcallback.proto + +package runtimev1 + +import ( + context "context" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + emptypb "google.golang.org/protobuf/types/known/emptypb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + AppCallback_OnInvoke_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnInvoke" + AppCallback_ListTopicSubscriptions_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/ListTopicSubscriptions" + AppCallback_OnTopicEvent_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnTopicEvent" + AppCallback_ListInputBindings_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/ListInputBindings" + AppCallback_OnBindingEvent_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnBindingEvent" +) + +// AppCallbackClient is the client API for AppCallback service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// AppCallback V1 allows user application to interact with Dapr runtime. +// User application needs to implement AppCallback service if it needs to +// receive message from dapr runtime. +type AppCallbackClient interface { + // Invokes service method with InvokeRequest. + OnInvoke(ctx context.Context, in *v1.InvokeRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) + // Lists all topics subscribed by this app. + ListTopicSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error) + // Subscribes events from Pubsub + OnTopicEvent(ctx context.Context, in *TopicEventRequest, opts ...grpc.CallOption) (*TopicEventResponse, error) + // Lists all input bindings subscribed by this app. + ListInputBindings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListInputBindingsResponse, error) + // Listens events from the input bindings + // + // User application can save the states or send the events to the output + // bindings optionally by returning BindingEventResponse. + OnBindingEvent(ctx context.Context, in *BindingEventRequest, opts ...grpc.CallOption) (*BindingEventResponse, error) +} + +type appCallbackClient struct { + cc grpc.ClientConnInterface +} + +func NewAppCallbackClient(cc grpc.ClientConnInterface) AppCallbackClient { + return &appCallbackClient{cc} +} + +func (c *appCallbackClient) OnInvoke(ctx context.Context, in *v1.InvokeRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(v1.InvokeResponse) + err := c.cc.Invoke(ctx, AppCallback_OnInvoke_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appCallbackClient) ListTopicSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListTopicSubscriptionsResponse) + err := c.cc.Invoke(ctx, AppCallback_ListTopicSubscriptions_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appCallbackClient) OnTopicEvent(ctx context.Context, in *TopicEventRequest, opts ...grpc.CallOption) (*TopicEventResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TopicEventResponse) + err := c.cc.Invoke(ctx, AppCallback_OnTopicEvent_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appCallbackClient) ListInputBindings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListInputBindingsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListInputBindingsResponse) + err := c.cc.Invoke(ctx, AppCallback_ListInputBindings_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appCallbackClient) OnBindingEvent(ctx context.Context, in *BindingEventRequest, opts ...grpc.CallOption) (*BindingEventResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BindingEventResponse) + err := c.cc.Invoke(ctx, AppCallback_OnBindingEvent_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AppCallbackServer is the server API for AppCallback service. +// All implementations must embed UnimplementedAppCallbackServer +// for forward compatibility. +// +// AppCallback V1 allows user application to interact with Dapr runtime. +// User application needs to implement AppCallback service if it needs to +// receive message from dapr runtime. +type AppCallbackServer interface { + // Invokes service method with InvokeRequest. + OnInvoke(context.Context, *v1.InvokeRequest) (*v1.InvokeResponse, error) + // Lists all topics subscribed by this app. + ListTopicSubscriptions(context.Context, *emptypb.Empty) (*ListTopicSubscriptionsResponse, error) + // Subscribes events from Pubsub + OnTopicEvent(context.Context, *TopicEventRequest) (*TopicEventResponse, error) + // Lists all input bindings subscribed by this app. + ListInputBindings(context.Context, *emptypb.Empty) (*ListInputBindingsResponse, error) + // Listens events from the input bindings + // + // User application can save the states or send the events to the output + // bindings optionally by returning BindingEventResponse. + OnBindingEvent(context.Context, *BindingEventRequest) (*BindingEventResponse, error) + mustEmbedUnimplementedAppCallbackServer() +} + +// UnimplementedAppCallbackServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedAppCallbackServer struct{} + +func (UnimplementedAppCallbackServer) OnInvoke(context.Context, *v1.InvokeRequest) (*v1.InvokeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OnInvoke not implemented") +} +func (UnimplementedAppCallbackServer) ListTopicSubscriptions(context.Context, *emptypb.Empty) (*ListTopicSubscriptionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListTopicSubscriptions not implemented") +} +func (UnimplementedAppCallbackServer) OnTopicEvent(context.Context, *TopicEventRequest) (*TopicEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OnTopicEvent not implemented") +} +func (UnimplementedAppCallbackServer) ListInputBindings(context.Context, *emptypb.Empty) (*ListInputBindingsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListInputBindings not implemented") +} +func (UnimplementedAppCallbackServer) OnBindingEvent(context.Context, *BindingEventRequest) (*BindingEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OnBindingEvent not implemented") +} +func (UnimplementedAppCallbackServer) mustEmbedUnimplementedAppCallbackServer() {} +func (UnimplementedAppCallbackServer) testEmbeddedByValue() {} + +// UnsafeAppCallbackServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AppCallbackServer will +// result in compilation errors. +type UnsafeAppCallbackServer interface { + mustEmbedUnimplementedAppCallbackServer() +} + +func RegisterAppCallbackServer(s grpc.ServiceRegistrar, srv AppCallbackServer) { + // If the following call pancis, it indicates UnimplementedAppCallbackServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&AppCallback_ServiceDesc, srv) +} + +func _AppCallback_OnInvoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1.InvokeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackServer).OnInvoke(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallback_OnInvoke_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackServer).OnInvoke(ctx, req.(*v1.InvokeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppCallback_ListTopicSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(emptypb.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackServer).ListTopicSubscriptions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallback_ListTopicSubscriptions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackServer).ListTopicSubscriptions(ctx, req.(*emptypb.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppCallback_OnTopicEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TopicEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackServer).OnTopicEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallback_OnTopicEvent_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackServer).OnTopicEvent(ctx, req.(*TopicEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppCallback_ListInputBindings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(emptypb.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackServer).ListInputBindings(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallback_ListInputBindings_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackServer).ListInputBindings(ctx, req.(*emptypb.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppCallback_OnBindingEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BindingEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackServer).OnBindingEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallback_OnBindingEvent_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackServer).OnBindingEvent(ctx, req.(*BindingEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// AppCallback_ServiceDesc is the grpc.ServiceDesc for AppCallback service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AppCallback_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "dapr.proto.runtime.v1.AppCallback", + HandlerType: (*AppCallbackServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "OnInvoke", + Handler: _AppCallback_OnInvoke_Handler, + }, + { + MethodName: "ListTopicSubscriptions", + Handler: _AppCallback_ListTopicSubscriptions_Handler, + }, + { + MethodName: "OnTopicEvent", + Handler: _AppCallback_OnTopicEvent_Handler, + }, + { + MethodName: "ListInputBindings", + Handler: _AppCallback_ListInputBindings_Handler, + }, + { + MethodName: "OnBindingEvent", + Handler: _AppCallback_OnBindingEvent_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "dapr/proto/runtime/v1/appcallback.proto", +} + +const ( + AppCallbackHealthCheck_HealthCheck_FullMethodName = "/dapr.proto.runtime.v1.AppCallbackHealthCheck/HealthCheck" +) + +// AppCallbackHealthCheckClient is the client API for AppCallbackHealthCheck service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// AppCallbackHealthCheck V1 is an optional extension to AppCallback V1 to implement +// the HealthCheck method. +type AppCallbackHealthCheckClient interface { + // Health check. + HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) +} + +type appCallbackHealthCheckClient struct { + cc grpc.ClientConnInterface +} + +func NewAppCallbackHealthCheckClient(cc grpc.ClientConnInterface) AppCallbackHealthCheckClient { + return &appCallbackHealthCheckClient{cc} +} + +func (c *appCallbackHealthCheckClient) HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HealthCheckResponse) + err := c.cc.Invoke(ctx, AppCallbackHealthCheck_HealthCheck_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AppCallbackHealthCheckServer is the server API for AppCallbackHealthCheck service. +// All implementations must embed UnimplementedAppCallbackHealthCheckServer +// for forward compatibility. +// +// AppCallbackHealthCheck V1 is an optional extension to AppCallback V1 to implement +// the HealthCheck method. +type AppCallbackHealthCheckServer interface { + // Health check. + HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) + mustEmbedUnimplementedAppCallbackHealthCheckServer() +} + +// UnimplementedAppCallbackHealthCheckServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedAppCallbackHealthCheckServer struct{} + +func (UnimplementedAppCallbackHealthCheckServer) HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HealthCheck not implemented") +} +func (UnimplementedAppCallbackHealthCheckServer) mustEmbedUnimplementedAppCallbackHealthCheckServer() { +} +func (UnimplementedAppCallbackHealthCheckServer) testEmbeddedByValue() {} + +// UnsafeAppCallbackHealthCheckServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AppCallbackHealthCheckServer will +// result in compilation errors. +type UnsafeAppCallbackHealthCheckServer interface { + mustEmbedUnimplementedAppCallbackHealthCheckServer() +} + +func RegisterAppCallbackHealthCheckServer(s grpc.ServiceRegistrar, srv AppCallbackHealthCheckServer) { + // If the following call pancis, it indicates UnimplementedAppCallbackHealthCheckServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&AppCallbackHealthCheck_ServiceDesc, srv) +} + +func _AppCallbackHealthCheck_HealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(emptypb.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackHealthCheckServer).HealthCheck(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallbackHealthCheck_HealthCheck_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackHealthCheckServer).HealthCheck(ctx, req.(*emptypb.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +// AppCallbackHealthCheck_ServiceDesc is the grpc.ServiceDesc for AppCallbackHealthCheck service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AppCallbackHealthCheck_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "dapr.proto.runtime.v1.AppCallbackHealthCheck", + HandlerType: (*AppCallbackHealthCheckServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "HealthCheck", + Handler: _AppCallbackHealthCheck_HealthCheck_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "dapr/proto/runtime/v1/appcallback.proto", +} + +const ( + AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName = "/dapr.proto.runtime.v1.AppCallbackAlpha/OnBulkTopicEventAlpha1" + AppCallbackAlpha_OnJobEventAlpha1_FullMethodName = "/dapr.proto.runtime.v1.AppCallbackAlpha/OnJobEventAlpha1" +) + +// AppCallbackAlphaClient is the client API for AppCallbackAlpha service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// AppCallbackAlpha V1 is an optional extension to AppCallback V1 to opt +// for Alpha RPCs. +type AppCallbackAlphaClient interface { + // Subscribes bulk events from Pubsub + OnBulkTopicEventAlpha1(ctx context.Context, in *TopicEventBulkRequest, opts ...grpc.CallOption) (*TopicEventBulkResponse, error) + // Sends job back to the app's endpoint at trigger time. + OnJobEventAlpha1(ctx context.Context, in *JobEventRequest, opts ...grpc.CallOption) (*JobEventResponse, error) +} + +type appCallbackAlphaClient struct { + cc grpc.ClientConnInterface +} + +func NewAppCallbackAlphaClient(cc grpc.ClientConnInterface) AppCallbackAlphaClient { + return &appCallbackAlphaClient{cc} +} + +func (c *appCallbackAlphaClient) OnBulkTopicEventAlpha1(ctx context.Context, in *TopicEventBulkRequest, opts ...grpc.CallOption) (*TopicEventBulkResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TopicEventBulkResponse) + err := c.cc.Invoke(ctx, AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *appCallbackAlphaClient) OnJobEventAlpha1(ctx context.Context, in *JobEventRequest, opts ...grpc.CallOption) (*JobEventResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(JobEventResponse) + err := c.cc.Invoke(ctx, AppCallbackAlpha_OnJobEventAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AppCallbackAlphaServer is the server API for AppCallbackAlpha service. +// All implementations must embed UnimplementedAppCallbackAlphaServer +// for forward compatibility. +// +// AppCallbackAlpha V1 is an optional extension to AppCallback V1 to opt +// for Alpha RPCs. +type AppCallbackAlphaServer interface { + // Subscribes bulk events from Pubsub + OnBulkTopicEventAlpha1(context.Context, *TopicEventBulkRequest) (*TopicEventBulkResponse, error) + // Sends job back to the app's endpoint at trigger time. + OnJobEventAlpha1(context.Context, *JobEventRequest) (*JobEventResponse, error) + mustEmbedUnimplementedAppCallbackAlphaServer() +} + +// UnimplementedAppCallbackAlphaServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedAppCallbackAlphaServer struct{} + +func (UnimplementedAppCallbackAlphaServer) OnBulkTopicEventAlpha1(context.Context, *TopicEventBulkRequest) (*TopicEventBulkResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OnBulkTopicEventAlpha1 not implemented") +} +func (UnimplementedAppCallbackAlphaServer) OnJobEventAlpha1(context.Context, *JobEventRequest) (*JobEventResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OnJobEventAlpha1 not implemented") +} +func (UnimplementedAppCallbackAlphaServer) mustEmbedUnimplementedAppCallbackAlphaServer() {} +func (UnimplementedAppCallbackAlphaServer) testEmbeddedByValue() {} + +// UnsafeAppCallbackAlphaServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AppCallbackAlphaServer will +// result in compilation errors. +type UnsafeAppCallbackAlphaServer interface { + mustEmbedUnimplementedAppCallbackAlphaServer() +} + +func RegisterAppCallbackAlphaServer(s grpc.ServiceRegistrar, srv AppCallbackAlphaServer) { + // If the following call pancis, it indicates UnimplementedAppCallbackAlphaServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&AppCallbackAlpha_ServiceDesc, srv) +} + +func _AppCallbackAlpha_OnBulkTopicEventAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TopicEventBulkRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackAlphaServer).OnBulkTopicEventAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackAlphaServer).OnBulkTopicEventAlpha1(ctx, req.(*TopicEventBulkRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AppCallbackAlpha_OnJobEventAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JobEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AppCallbackAlphaServer).OnJobEventAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: AppCallbackAlpha_OnJobEventAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AppCallbackAlphaServer).OnJobEventAlpha1(ctx, req.(*JobEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// AppCallbackAlpha_ServiceDesc is the grpc.ServiceDesc for AppCallbackAlpha service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AppCallbackAlpha_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "dapr.proto.runtime.v1.AppCallbackAlpha", + HandlerType: (*AppCallbackAlphaServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "OnBulkTopicEventAlpha1", + Handler: _AppCallbackAlpha_OnBulkTopicEventAlpha1_Handler, + }, + { + MethodName: "OnJobEventAlpha1", + Handler: _AppCallbackAlpha_OnJobEventAlpha1_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "dapr/proto/runtime/v1/appcallback.proto", +} diff --git a/internal/proto/dapr/proto/runtime/v1/dapr.pb.go b/internal/proto/dapr/proto/runtime/v1/dapr.pb.go new file mode 100644 index 00000000..4f8aab64 --- /dev/null +++ b/internal/proto/dapr/proto/runtime/v1/dapr.pb.go @@ -0,0 +1,7997 @@ +// +//Copyright 2021 The Dapr Authors +//Licensed under the Apache License, Version 2.0 (the "License"); +//you may not use this file except in compliance with the License. +//You may obtain a copy of the License at +//http://www.apache.org/licenses/LICENSE-2.0 +//Unless required by applicable law or agreed to in writing, software +//distributed under the License is distributed on an "AS IS" BASIS, +//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//See the License for the specific language governing permissions and +//limitations under the License. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.6 +// protoc (unknown) +// source: dapr/proto/runtime/v1/dapr.proto + +package runtimev1 + +import ( + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + emptypb "google.golang.org/protobuf/types/known/emptypb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// PubsubSubscriptionType indicates the type of subscription +type PubsubSubscriptionType int32 + +const ( + // UNKNOWN is the default value for the subscription type. + PubsubSubscriptionType_UNKNOWN PubsubSubscriptionType = 0 + // Declarative subscription (k8s CRD) + PubsubSubscriptionType_DECLARATIVE PubsubSubscriptionType = 1 + // Programmatically created subscription + PubsubSubscriptionType_PROGRAMMATIC PubsubSubscriptionType = 2 + // Bidirectional Streaming subscription + PubsubSubscriptionType_STREAMING PubsubSubscriptionType = 3 +) + +// Enum value maps for PubsubSubscriptionType. +var ( + PubsubSubscriptionType_name = map[int32]string{ + 0: "UNKNOWN", + 1: "DECLARATIVE", + 2: "PROGRAMMATIC", + 3: "STREAMING", + } + PubsubSubscriptionType_value = map[string]int32{ + "UNKNOWN": 0, + "DECLARATIVE": 1, + "PROGRAMMATIC": 2, + "STREAMING": 3, + } +) + +func (x PubsubSubscriptionType) Enum() *PubsubSubscriptionType { + p := new(PubsubSubscriptionType) + *p = x + return p +} + +func (x PubsubSubscriptionType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (PubsubSubscriptionType) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[0].Descriptor() +} + +func (PubsubSubscriptionType) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[0] +} + +func (x PubsubSubscriptionType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use PubsubSubscriptionType.Descriptor instead. +func (PubsubSubscriptionType) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{0} +} + +type ActorRuntime_ActorRuntimeStatus int32 + +const ( + // Indicates that the actor runtime is still being initialized. + ActorRuntime_INITIALIZING ActorRuntime_ActorRuntimeStatus = 0 + // Indicates that the actor runtime is disabled. + // This normally happens when Dapr is started without "placement-host-address" + ActorRuntime_DISABLED ActorRuntime_ActorRuntimeStatus = 1 + // Indicates the actor runtime is running, either as an actor host or client. + ActorRuntime_RUNNING ActorRuntime_ActorRuntimeStatus = 2 +) + +// Enum value maps for ActorRuntime_ActorRuntimeStatus. +var ( + ActorRuntime_ActorRuntimeStatus_name = map[int32]string{ + 0: "INITIALIZING", + 1: "DISABLED", + 2: "RUNNING", + } + ActorRuntime_ActorRuntimeStatus_value = map[string]int32{ + "INITIALIZING": 0, + "DISABLED": 1, + "RUNNING": 2, + } +) + +func (x ActorRuntime_ActorRuntimeStatus) Enum() *ActorRuntime_ActorRuntimeStatus { + p := new(ActorRuntime_ActorRuntimeStatus) + *p = x + return p +} + +func (x ActorRuntime_ActorRuntimeStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ActorRuntime_ActorRuntimeStatus) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[1].Descriptor() +} + +func (ActorRuntime_ActorRuntimeStatus) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[1] +} + +func (x ActorRuntime_ActorRuntimeStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ActorRuntime_ActorRuntimeStatus.Descriptor instead. +func (ActorRuntime_ActorRuntimeStatus) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{44, 0} +} + +type UnlockResponse_Status int32 + +const ( + UnlockResponse_SUCCESS UnlockResponse_Status = 0 + UnlockResponse_LOCK_DOES_NOT_EXIST UnlockResponse_Status = 1 + UnlockResponse_LOCK_BELONGS_TO_OTHERS UnlockResponse_Status = 2 + UnlockResponse_INTERNAL_ERROR UnlockResponse_Status = 3 +) + +// Enum value maps for UnlockResponse_Status. +var ( + UnlockResponse_Status_name = map[int32]string{ + 0: "SUCCESS", + 1: "LOCK_DOES_NOT_EXIST", + 2: "LOCK_BELONGS_TO_OTHERS", + 3: "INTERNAL_ERROR", + } + UnlockResponse_Status_value = map[string]int32{ + "SUCCESS": 0, + "LOCK_DOES_NOT_EXIST": 1, + "LOCK_BELONGS_TO_OTHERS": 2, + "INTERNAL_ERROR": 3, + } +) + +func (x UnlockResponse_Status) Enum() *UnlockResponse_Status { + p := new(UnlockResponse_Status) + *p = x + return p +} + +func (x UnlockResponse_Status) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (UnlockResponse_Status) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[2].Descriptor() +} + +func (UnlockResponse_Status) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[2] +} + +func (x UnlockResponse_Status) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use UnlockResponse_Status.Descriptor instead. +func (UnlockResponse_Status) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{63, 0} +} + +type SubtleGetKeyRequest_KeyFormat int32 + +const ( + // PEM (PKIX) (default) + SubtleGetKeyRequest_PEM SubtleGetKeyRequest_KeyFormat = 0 + // JSON (JSON Web Key) as string + SubtleGetKeyRequest_JSON SubtleGetKeyRequest_KeyFormat = 1 +) + +// Enum value maps for SubtleGetKeyRequest_KeyFormat. +var ( + SubtleGetKeyRequest_KeyFormat_name = map[int32]string{ + 0: "PEM", + 1: "JSON", + } + SubtleGetKeyRequest_KeyFormat_value = map[string]int32{ + "PEM": 0, + "JSON": 1, + } +) + +func (x SubtleGetKeyRequest_KeyFormat) Enum() *SubtleGetKeyRequest_KeyFormat { + p := new(SubtleGetKeyRequest_KeyFormat) + *p = x + return p +} + +func (x SubtleGetKeyRequest_KeyFormat) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SubtleGetKeyRequest_KeyFormat) Descriptor() protoreflect.EnumDescriptor { + return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[3].Descriptor() +} + +func (SubtleGetKeyRequest_KeyFormat) Type() protoreflect.EnumType { + return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[3] +} + +func (x SubtleGetKeyRequest_KeyFormat) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SubtleGetKeyRequest_KeyFormat.Descriptor instead. +func (SubtleGetKeyRequest_KeyFormat) EnumDescriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{64, 0} +} + +// InvokeServiceRequest represents the request message for Service invocation. +type InvokeServiceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. Callee's app id. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Required. message which will be delivered to callee. + Message *v1.InvokeRequest `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeServiceRequest) Reset() { + *x = InvokeServiceRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeServiceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeServiceRequest) ProtoMessage() {} + +func (x *InvokeServiceRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeServiceRequest.ProtoReflect.Descriptor instead. +func (*InvokeServiceRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{0} +} + +func (x *InvokeServiceRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *InvokeServiceRequest) GetMessage() *v1.InvokeRequest { + if x != nil { + return x.Message + } + return nil +} + +// GetStateRequest is the message to get key-value states from specific state store. +type GetStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The key of the desired state + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // The read consistency of the state store. + Consistency v1.StateOptions_StateConsistency `protobuf:"varint,3,opt,name=consistency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConsistency" json:"consistency,omitempty"` + // The metadata which will be sent to state store components. + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetStateRequest) Reset() { + *x = GetStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetStateRequest) ProtoMessage() {} + +func (x *GetStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetStateRequest.ProtoReflect.Descriptor instead. +func (*GetStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{1} +} + +func (x *GetStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *GetStateRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GetStateRequest) GetConsistency() v1.StateOptions_StateConsistency { + if x != nil { + return x.Consistency + } + return v1.StateOptions_StateConsistency(0) +} + +func (x *GetStateRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetBulkStateRequest is the message to get a list of key-value states from specific state store. +type GetBulkStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The keys to get. + Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + // The number of parallel operations executed on the state store for a get operation. + Parallelism int32 `protobuf:"varint,3,opt,name=parallelism,proto3" json:"parallelism,omitempty"` + // The metadata which will be sent to state store components. + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBulkStateRequest) Reset() { + *x = GetBulkStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBulkStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBulkStateRequest) ProtoMessage() {} + +func (x *GetBulkStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBulkStateRequest.ProtoReflect.Descriptor instead. +func (*GetBulkStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{2} +} + +func (x *GetBulkStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *GetBulkStateRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +func (x *GetBulkStateRequest) GetParallelism() int32 { + if x != nil { + return x.Parallelism + } + return 0 +} + +func (x *GetBulkStateRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetBulkStateResponse is the response conveying the list of state values. +type GetBulkStateResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of items containing the keys to get values for. + Items []*BulkStateItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBulkStateResponse) Reset() { + *x = GetBulkStateResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBulkStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBulkStateResponse) ProtoMessage() {} + +func (x *GetBulkStateResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBulkStateResponse.ProtoReflect.Descriptor instead. +func (*GetBulkStateResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{3} +} + +func (x *GetBulkStateResponse) GetItems() []*BulkStateItem { + if x != nil { + return x.Items + } + return nil +} + +// BulkStateItem is the response item for a bulk get operation. +// Return values include the item key, data and etag. +type BulkStateItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // state item key + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // The byte array data + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // The entity tag which represents the specific version of data. + // ETag format is defined by the corresponding data store. + Etag string `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"` + // The error that was returned from the state store in case of a failed get operation. + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` + // The metadata which will be sent to app. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkStateItem) Reset() { + *x = BulkStateItem{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkStateItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkStateItem) ProtoMessage() {} + +func (x *BulkStateItem) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkStateItem.ProtoReflect.Descriptor instead. +func (*BulkStateItem) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{4} +} + +func (x *BulkStateItem) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *BulkStateItem) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *BulkStateItem) GetEtag() string { + if x != nil { + return x.Etag + } + return "" +} + +func (x *BulkStateItem) GetError() string { + if x != nil { + return x.Error + } + return "" +} + +func (x *BulkStateItem) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetStateResponse is the response conveying the state value and etag. +type GetStateResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The byte array data + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // The entity tag which represents the specific version of data. + // ETag format is defined by the corresponding data store. + Etag string `protobuf:"bytes,2,opt,name=etag,proto3" json:"etag,omitempty"` + // The metadata which will be sent to app. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetStateResponse) Reset() { + *x = GetStateResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetStateResponse) ProtoMessage() {} + +func (x *GetStateResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetStateResponse.ProtoReflect.Descriptor instead. +func (*GetStateResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{5} +} + +func (x *GetStateResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *GetStateResponse) GetEtag() string { + if x != nil { + return x.Etag + } + return "" +} + +func (x *GetStateResponse) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// DeleteStateRequest is the message to delete key-value states in the specific state store. +type DeleteStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The key of the desired state + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // The entity tag which represents the specific version of data. + // The exact ETag format is defined by the corresponding data store. + Etag *v1.Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"` + // State operation options which includes concurrency/ + // consistency/retry_policy. + Options *v1.StateOptions `protobuf:"bytes,4,opt,name=options,proto3" json:"options,omitempty"` + // The metadata which will be sent to state store components. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteStateRequest) Reset() { + *x = DeleteStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteStateRequest) ProtoMessage() {} + +func (x *DeleteStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteStateRequest.ProtoReflect.Descriptor instead. +func (*DeleteStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{6} +} + +func (x *DeleteStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *DeleteStateRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *DeleteStateRequest) GetEtag() *v1.Etag { + if x != nil { + return x.Etag + } + return nil +} + +func (x *DeleteStateRequest) GetOptions() *v1.StateOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *DeleteStateRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// DeleteBulkStateRequest is the message to delete a list of key-value states from specific state store. +type DeleteBulkStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The array of the state key values. + States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteBulkStateRequest) Reset() { + *x = DeleteBulkStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteBulkStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteBulkStateRequest) ProtoMessage() {} + +func (x *DeleteBulkStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteBulkStateRequest.ProtoReflect.Descriptor instead. +func (*DeleteBulkStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{7} +} + +func (x *DeleteBulkStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *DeleteBulkStateRequest) GetStates() []*v1.StateItem { + if x != nil { + return x.States + } + return nil +} + +// SaveStateRequest is the message to save multiple states into state store. +type SaveStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The array of the state key values. + States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SaveStateRequest) Reset() { + *x = SaveStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SaveStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SaveStateRequest) ProtoMessage() {} + +func (x *SaveStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SaveStateRequest.ProtoReflect.Descriptor instead. +func (*SaveStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{8} +} + +func (x *SaveStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *SaveStateRequest) GetStates() []*v1.StateItem { + if x != nil { + return x.States + } + return nil +} + +// QueryStateRequest is the message to query state store. +type QueryStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of state store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The query in JSON format. + Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"` + // The metadata which will be sent to state store components. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryStateRequest) Reset() { + *x = QueryStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryStateRequest) ProtoMessage() {} + +func (x *QueryStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QueryStateRequest.ProtoReflect.Descriptor instead. +func (*QueryStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{9} +} + +func (x *QueryStateRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *QueryStateRequest) GetQuery() string { + if x != nil { + return x.Query + } + return "" +} + +func (x *QueryStateRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +type QueryStateItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The object key. + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // The object value. + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // The entity tag which represents the specific version of data. + // ETag format is defined by the corresponding data store. + Etag string `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"` + // The error message indicating an error in processing of the query result. + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryStateItem) Reset() { + *x = QueryStateItem{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryStateItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryStateItem) ProtoMessage() {} + +func (x *QueryStateItem) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QueryStateItem.ProtoReflect.Descriptor instead. +func (*QueryStateItem) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{10} +} + +func (x *QueryStateItem) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *QueryStateItem) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *QueryStateItem) GetEtag() string { + if x != nil { + return x.Etag + } + return "" +} + +func (x *QueryStateItem) GetError() string { + if x != nil { + return x.Error + } + return "" +} + +// QueryStateResponse is the response conveying the query results. +type QueryStateResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // An array of query results. + Results []*QueryStateItem `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` + // Pagination token. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // The metadata which will be sent to app. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *QueryStateResponse) Reset() { + *x = QueryStateResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *QueryStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryStateResponse) ProtoMessage() {} + +func (x *QueryStateResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use QueryStateResponse.ProtoReflect.Descriptor instead. +func (*QueryStateResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{11} +} + +func (x *QueryStateResponse) GetResults() []*QueryStateItem { + if x != nil { + return x.Results + } + return nil +} + +func (x *QueryStateResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +func (x *QueryStateResponse) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// PublishEventRequest is the message to publish event data to pubsub topic +type PublishEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the pubsub component + PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // The pubsub topic + Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"` + // The data which will be published to topic. + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + // The content type for the data (optional). + DataContentType string `protobuf:"bytes,4,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"` + // The metadata passing to pub components + // + // metadata property: + // - key : the key of the message. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PublishEventRequest) Reset() { + *x = PublishEventRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PublishEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PublishEventRequest) ProtoMessage() {} + +func (x *PublishEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PublishEventRequest.ProtoReflect.Descriptor instead. +func (*PublishEventRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{12} +} + +func (x *PublishEventRequest) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *PublishEventRequest) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *PublishEventRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *PublishEventRequest) GetDataContentType() string { + if x != nil { + return x.DataContentType + } + return "" +} + +func (x *PublishEventRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// BulkPublishRequest is the message to bulk publish events to pubsub topic +type BulkPublishRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the pubsub component + PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // The pubsub topic + Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"` + // The entries which contain the individual events and associated details to be published + Entries []*BulkPublishRequestEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries,omitempty"` + // The request level metadata passing to to the pubsub components + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkPublishRequest) Reset() { + *x = BulkPublishRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkPublishRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkPublishRequest) ProtoMessage() {} + +func (x *BulkPublishRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkPublishRequest.ProtoReflect.Descriptor instead. +func (*BulkPublishRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{13} +} + +func (x *BulkPublishRequest) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *BulkPublishRequest) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *BulkPublishRequest) GetEntries() []*BulkPublishRequestEntry { + if x != nil { + return x.Entries + } + return nil +} + +func (x *BulkPublishRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// BulkPublishRequestEntry is the message containing the event to be bulk published +type BulkPublishRequestEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The request scoped unique ID referring to this message. Used to map status in response + EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"` + // The event which will be pulished to the topic + Event []byte `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"` + // The content type for the event + ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // The event level metadata passing to the pubsub component + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkPublishRequestEntry) Reset() { + *x = BulkPublishRequestEntry{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkPublishRequestEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkPublishRequestEntry) ProtoMessage() {} + +func (x *BulkPublishRequestEntry) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkPublishRequestEntry.ProtoReflect.Descriptor instead. +func (*BulkPublishRequestEntry) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{14} +} + +func (x *BulkPublishRequestEntry) GetEntryId() string { + if x != nil { + return x.EntryId + } + return "" +} + +func (x *BulkPublishRequestEntry) GetEvent() []byte { + if x != nil { + return x.Event + } + return nil +} + +func (x *BulkPublishRequestEntry) GetContentType() string { + if x != nil { + return x.ContentType + } + return "" +} + +func (x *BulkPublishRequestEntry) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// BulkPublishResponse is the message returned from a BulkPublishEvent call +type BulkPublishResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The entries for different events that failed publish in the BulkPublishEvent call + FailedEntries []*BulkPublishResponseFailedEntry `protobuf:"bytes,1,rep,name=failedEntries,proto3" json:"failedEntries,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkPublishResponse) Reset() { + *x = BulkPublishResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkPublishResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkPublishResponse) ProtoMessage() {} + +func (x *BulkPublishResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkPublishResponse.ProtoReflect.Descriptor instead. +func (*BulkPublishResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{15} +} + +func (x *BulkPublishResponse) GetFailedEntries() []*BulkPublishResponseFailedEntry { + if x != nil { + return x.FailedEntries + } + return nil +} + +// BulkPublishResponseFailedEntry is the message containing the entryID and error of a failed event in BulkPublishEvent call +type BulkPublishResponseFailedEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The response scoped unique ID referring to this message + EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"` + // The error message if any on failure + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BulkPublishResponseFailedEntry) Reset() { + *x = BulkPublishResponseFailedEntry{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BulkPublishResponseFailedEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BulkPublishResponseFailedEntry) ProtoMessage() {} + +func (x *BulkPublishResponseFailedEntry) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BulkPublishResponseFailedEntry.ProtoReflect.Descriptor instead. +func (*BulkPublishResponseFailedEntry) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{16} +} + +func (x *BulkPublishResponseFailedEntry) GetEntryId() string { + if x != nil { + return x.EntryId + } + return "" +} + +func (x *BulkPublishResponseFailedEntry) GetError() string { + if x != nil { + return x.Error + } + return "" +} + +// SubscribeTopicEventsRequestAlpha1 is a message containing the details for +// subscribing to a topic via streaming. +// The first message must always be the initial request. All subsequent +// messages must be event processed responses. +type SubscribeTopicEventsRequestAlpha1 struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to SubscribeTopicEventsRequestType: + // + // *SubscribeTopicEventsRequestAlpha1_InitialRequest + // *SubscribeTopicEventsRequestAlpha1_EventProcessed + SubscribeTopicEventsRequestType isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType `protobuf_oneof:"subscribe_topic_events_request_type"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeTopicEventsRequestAlpha1) Reset() { + *x = SubscribeTopicEventsRequestAlpha1{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeTopicEventsRequestAlpha1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeTopicEventsRequestAlpha1) ProtoMessage() {} + +func (x *SubscribeTopicEventsRequestAlpha1) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeTopicEventsRequestAlpha1.ProtoReflect.Descriptor instead. +func (*SubscribeTopicEventsRequestAlpha1) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{17} +} + +func (x *SubscribeTopicEventsRequestAlpha1) GetSubscribeTopicEventsRequestType() isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType { + if x != nil { + return x.SubscribeTopicEventsRequestType + } + return nil +} + +func (x *SubscribeTopicEventsRequestAlpha1) GetInitialRequest() *SubscribeTopicEventsRequestInitialAlpha1 { + if x != nil { + if x, ok := x.SubscribeTopicEventsRequestType.(*SubscribeTopicEventsRequestAlpha1_InitialRequest); ok { + return x.InitialRequest + } + } + return nil +} + +func (x *SubscribeTopicEventsRequestAlpha1) GetEventProcessed() *SubscribeTopicEventsRequestProcessedAlpha1 { + if x != nil { + if x, ok := x.SubscribeTopicEventsRequestType.(*SubscribeTopicEventsRequestAlpha1_EventProcessed); ok { + return x.EventProcessed + } + } + return nil +} + +type isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType interface { + isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType() +} + +type SubscribeTopicEventsRequestAlpha1_InitialRequest struct { + InitialRequest *SubscribeTopicEventsRequestInitialAlpha1 `protobuf:"bytes,1,opt,name=initial_request,json=initialRequest,proto3,oneof"` +} + +type SubscribeTopicEventsRequestAlpha1_EventProcessed struct { + EventProcessed *SubscribeTopicEventsRequestProcessedAlpha1 `protobuf:"bytes,2,opt,name=event_processed,json=eventProcessed,proto3,oneof"` +} + +func (*SubscribeTopicEventsRequestAlpha1_InitialRequest) isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType() { +} + +func (*SubscribeTopicEventsRequestAlpha1_EventProcessed) isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType() { +} + +// SubscribeTopicEventsRequestInitialAlpha1 is the initial message containing +// the details for subscribing to a topic via streaming. +type SubscribeTopicEventsRequestInitialAlpha1 struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the pubsub component + PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"` + // The pubsub topic + Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"` + // The metadata passing to pub components + // + // metadata property: + // - key : the key of the message. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // dead_letter_topic is the topic to which messages that fail to be processed + // are sent. + DeadLetterTopic *string `protobuf:"bytes,4,opt,name=dead_letter_topic,json=deadLetterTopic,proto3,oneof" json:"dead_letter_topic,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) Reset() { + *x = SubscribeTopicEventsRequestInitialAlpha1{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeTopicEventsRequestInitialAlpha1) ProtoMessage() {} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeTopicEventsRequestInitialAlpha1.ProtoReflect.Descriptor instead. +func (*SubscribeTopicEventsRequestInitialAlpha1) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{18} +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *SubscribeTopicEventsRequestInitialAlpha1) GetDeadLetterTopic() string { + if x != nil && x.DeadLetterTopic != nil { + return *x.DeadLetterTopic + } + return "" +} + +// SubscribeTopicEventsRequestProcessedAlpha1 is the message containing the +// subscription to a topic. +type SubscribeTopicEventsRequestProcessedAlpha1 struct { + state protoimpl.MessageState `protogen:"open.v1"` + // id is the unique identifier for the subscription request. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // status is the result of the subscription request. + Status *TopicEventResponse `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeTopicEventsRequestProcessedAlpha1) Reset() { + *x = SubscribeTopicEventsRequestProcessedAlpha1{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeTopicEventsRequestProcessedAlpha1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeTopicEventsRequestProcessedAlpha1) ProtoMessage() {} + +func (x *SubscribeTopicEventsRequestProcessedAlpha1) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeTopicEventsRequestProcessedAlpha1.ProtoReflect.Descriptor instead. +func (*SubscribeTopicEventsRequestProcessedAlpha1) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{19} +} + +func (x *SubscribeTopicEventsRequestProcessedAlpha1) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *SubscribeTopicEventsRequestProcessedAlpha1) GetStatus() *TopicEventResponse { + if x != nil { + return x.Status + } + return nil +} + +// SubscribeTopicEventsResponseAlpha1 is a message returned from daprd +// when subscribing to a topic via streaming. +type SubscribeTopicEventsResponseAlpha1 struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to SubscribeTopicEventsResponseType: + // + // *SubscribeTopicEventsResponseAlpha1_InitialResponse + // *SubscribeTopicEventsResponseAlpha1_EventMessage + SubscribeTopicEventsResponseType isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType `protobuf_oneof:"subscribe_topic_events_response_type"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeTopicEventsResponseAlpha1) Reset() { + *x = SubscribeTopicEventsResponseAlpha1{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeTopicEventsResponseAlpha1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeTopicEventsResponseAlpha1) ProtoMessage() {} + +func (x *SubscribeTopicEventsResponseAlpha1) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeTopicEventsResponseAlpha1.ProtoReflect.Descriptor instead. +func (*SubscribeTopicEventsResponseAlpha1) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{20} +} + +func (x *SubscribeTopicEventsResponseAlpha1) GetSubscribeTopicEventsResponseType() isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType { + if x != nil { + return x.SubscribeTopicEventsResponseType + } + return nil +} + +func (x *SubscribeTopicEventsResponseAlpha1) GetInitialResponse() *SubscribeTopicEventsResponseInitialAlpha1 { + if x != nil { + if x, ok := x.SubscribeTopicEventsResponseType.(*SubscribeTopicEventsResponseAlpha1_InitialResponse); ok { + return x.InitialResponse + } + } + return nil +} + +func (x *SubscribeTopicEventsResponseAlpha1) GetEventMessage() *TopicEventRequest { + if x != nil { + if x, ok := x.SubscribeTopicEventsResponseType.(*SubscribeTopicEventsResponseAlpha1_EventMessage); ok { + return x.EventMessage + } + } + return nil +} + +type isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType interface { + isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType() +} + +type SubscribeTopicEventsResponseAlpha1_InitialResponse struct { + InitialResponse *SubscribeTopicEventsResponseInitialAlpha1 `protobuf:"bytes,1,opt,name=initial_response,json=initialResponse,proto3,oneof"` +} + +type SubscribeTopicEventsResponseAlpha1_EventMessage struct { + EventMessage *TopicEventRequest `protobuf:"bytes,2,opt,name=event_message,json=eventMessage,proto3,oneof"` +} + +func (*SubscribeTopicEventsResponseAlpha1_InitialResponse) isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType() { +} + +func (*SubscribeTopicEventsResponseAlpha1_EventMessage) isSubscribeTopicEventsResponseAlpha1_SubscribeTopicEventsResponseType() { +} + +// SubscribeTopicEventsResponseInitialAlpha1 is the initial response from daprd +// when subscribing to a topic. +type SubscribeTopicEventsResponseInitialAlpha1 struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeTopicEventsResponseInitialAlpha1) Reset() { + *x = SubscribeTopicEventsResponseInitialAlpha1{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeTopicEventsResponseInitialAlpha1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeTopicEventsResponseInitialAlpha1) ProtoMessage() {} + +func (x *SubscribeTopicEventsResponseInitialAlpha1) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeTopicEventsResponseInitialAlpha1.ProtoReflect.Descriptor instead. +func (*SubscribeTopicEventsResponseInitialAlpha1) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{21} +} + +// InvokeBindingRequest is the message to send data to output bindings +type InvokeBindingRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the output binding to invoke. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // The data which will be sent to output binding. + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + // The metadata passing to output binding components + // + // Common metadata property: + // - ttlInSeconds : the time to live in seconds for the message. + // + // If set in the binding definition will cause all messages to + // have a default time to live. The message ttl overrides any value + // in the binding definition. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The name of the operation type for the binding to invoke + Operation string `protobuf:"bytes,4,opt,name=operation,proto3" json:"operation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeBindingRequest) Reset() { + *x = InvokeBindingRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeBindingRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeBindingRequest) ProtoMessage() {} + +func (x *InvokeBindingRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeBindingRequest.ProtoReflect.Descriptor instead. +func (*InvokeBindingRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{22} +} + +func (x *InvokeBindingRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *InvokeBindingRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *InvokeBindingRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *InvokeBindingRequest) GetOperation() string { + if x != nil { + return x.Operation + } + return "" +} + +// InvokeBindingResponse is the message returned from an output binding invocation +type InvokeBindingResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The data which will be sent to output binding. + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // The metadata returned from an external system + Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeBindingResponse) Reset() { + *x = InvokeBindingResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeBindingResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeBindingResponse) ProtoMessage() {} + +func (x *InvokeBindingResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeBindingResponse.ProtoReflect.Descriptor instead. +func (*InvokeBindingResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{23} +} + +func (x *InvokeBindingResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *InvokeBindingResponse) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetSecretRequest is the message to get secret from secret store. +type GetSecretRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of secret store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The name of secret key. + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + // The metadata which will be sent to secret store components. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSecretRequest) Reset() { + *x = GetSecretRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSecretRequest) ProtoMessage() {} + +func (x *GetSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSecretRequest.ProtoReflect.Descriptor instead. +func (*GetSecretRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{24} +} + +func (x *GetSecretRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *GetSecretRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GetSecretRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetSecretResponse is the response message to convey the requested secret. +type GetSecretResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // data is the secret value. Some secret store, such as kubernetes secret + // store, can save multiple secrets for single secret key. + Data map[string]string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSecretResponse) Reset() { + *x = GetSecretResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSecretResponse) ProtoMessage() {} + +func (x *GetSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSecretResponse.ProtoReflect.Descriptor instead. +func (*GetSecretResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{25} +} + +func (x *GetSecretResponse) GetData() map[string]string { + if x != nil { + return x.Data + } + return nil +} + +// GetBulkSecretRequest is the message to get the secrets from secret store. +type GetBulkSecretRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of secret store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The metadata which will be sent to secret store components. + Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBulkSecretRequest) Reset() { + *x = GetBulkSecretRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBulkSecretRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBulkSecretRequest) ProtoMessage() {} + +func (x *GetBulkSecretRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBulkSecretRequest.ProtoReflect.Descriptor instead. +func (*GetBulkSecretRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{26} +} + +func (x *GetBulkSecretRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *GetBulkSecretRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// SecretResponse is a map of decrypted string/string values +type SecretResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Secrets map[string]string `protobuf:"bytes,1,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SecretResponse) Reset() { + *x = SecretResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SecretResponse) ProtoMessage() {} + +func (x *SecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SecretResponse.ProtoReflect.Descriptor instead. +func (*SecretResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{27} +} + +func (x *SecretResponse) GetSecrets() map[string]string { + if x != nil { + return x.Secrets + } + return nil +} + +// GetBulkSecretResponse is the response message to convey the requested secrets. +type GetBulkSecretResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // data hold the secret values. Some secret store, such as kubernetes secret + // store, can save multiple secrets for single secret key. + Data map[string]*SecretResponse `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBulkSecretResponse) Reset() { + *x = GetBulkSecretResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBulkSecretResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBulkSecretResponse) ProtoMessage() {} + +func (x *GetBulkSecretResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBulkSecretResponse.ProtoReflect.Descriptor instead. +func (*GetBulkSecretResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{28} +} + +func (x *GetBulkSecretResponse) GetData() map[string]*SecretResponse { + if x != nil { + return x.Data + } + return nil +} + +// TransactionalStateOperation is the message to execute a specified operation with a key-value pair. +type TransactionalStateOperation struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The type of operation to be executed + OperationType string `protobuf:"bytes,1,opt,name=operationType,proto3" json:"operationType,omitempty"` + // State values to be operated on + Request *v1.StateItem `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TransactionalStateOperation) Reset() { + *x = TransactionalStateOperation{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TransactionalStateOperation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TransactionalStateOperation) ProtoMessage() {} + +func (x *TransactionalStateOperation) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TransactionalStateOperation.ProtoReflect.Descriptor instead. +func (*TransactionalStateOperation) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{29} +} + +func (x *TransactionalStateOperation) GetOperationType() string { + if x != nil { + return x.OperationType + } + return "" +} + +func (x *TransactionalStateOperation) GetRequest() *v1.StateItem { + if x != nil { + return x.Request + } + return nil +} + +// ExecuteStateTransactionRequest is the message to execute multiple operations on a specified store. +type ExecuteStateTransactionRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. name of state store. + StoreName string `protobuf:"bytes,1,opt,name=storeName,proto3" json:"storeName,omitempty"` + // Required. transactional operation list. + Operations []*TransactionalStateOperation `protobuf:"bytes,2,rep,name=operations,proto3" json:"operations,omitempty"` + // The metadata used for transactional operations. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExecuteStateTransactionRequest) Reset() { + *x = ExecuteStateTransactionRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecuteStateTransactionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecuteStateTransactionRequest) ProtoMessage() {} + +func (x *ExecuteStateTransactionRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecuteStateTransactionRequest.ProtoReflect.Descriptor instead. +func (*ExecuteStateTransactionRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{30} +} + +func (x *ExecuteStateTransactionRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *ExecuteStateTransactionRequest) GetOperations() []*TransactionalStateOperation { + if x != nil { + return x.Operations + } + return nil +} + +func (x *ExecuteStateTransactionRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// RegisterActorTimerRequest is the message to register a timer for an actor of a given type and id. +type RegisterActorTimerRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + DueTime string `protobuf:"bytes,4,opt,name=due_time,json=dueTime,proto3" json:"due_time,omitempty"` + Period string `protobuf:"bytes,5,opt,name=period,proto3" json:"period,omitempty"` + Callback string `protobuf:"bytes,6,opt,name=callback,proto3" json:"callback,omitempty"` + Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` + Ttl string `protobuf:"bytes,8,opt,name=ttl,proto3" json:"ttl,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RegisterActorTimerRequest) Reset() { + *x = RegisterActorTimerRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RegisterActorTimerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RegisterActorTimerRequest) ProtoMessage() {} + +func (x *RegisterActorTimerRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RegisterActorTimerRequest.ProtoReflect.Descriptor instead. +func (*RegisterActorTimerRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{31} +} + +func (x *RegisterActorTimerRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *RegisterActorTimerRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *RegisterActorTimerRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *RegisterActorTimerRequest) GetDueTime() string { + if x != nil { + return x.DueTime + } + return "" +} + +func (x *RegisterActorTimerRequest) GetPeriod() string { + if x != nil { + return x.Period + } + return "" +} + +func (x *RegisterActorTimerRequest) GetCallback() string { + if x != nil { + return x.Callback + } + return "" +} + +func (x *RegisterActorTimerRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *RegisterActorTimerRequest) GetTtl() string { + if x != nil { + return x.Ttl + } + return "" +} + +// UnregisterActorTimerRequest is the message to unregister an actor timer +type UnregisterActorTimerRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnregisterActorTimerRequest) Reset() { + *x = UnregisterActorTimerRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnregisterActorTimerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnregisterActorTimerRequest) ProtoMessage() {} + +func (x *UnregisterActorTimerRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnregisterActorTimerRequest.ProtoReflect.Descriptor instead. +func (*UnregisterActorTimerRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{32} +} + +func (x *UnregisterActorTimerRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *UnregisterActorTimerRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *UnregisterActorTimerRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// RegisterActorReminderRequest is the message to register a reminder for an actor of a given type and id. +type RegisterActorReminderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + DueTime string `protobuf:"bytes,4,opt,name=due_time,json=dueTime,proto3" json:"due_time,omitempty"` + Period string `protobuf:"bytes,5,opt,name=period,proto3" json:"period,omitempty"` + Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` + Ttl string `protobuf:"bytes,7,opt,name=ttl,proto3" json:"ttl,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RegisterActorReminderRequest) Reset() { + *x = RegisterActorReminderRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RegisterActorReminderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RegisterActorReminderRequest) ProtoMessage() {} + +func (x *RegisterActorReminderRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RegisterActorReminderRequest.ProtoReflect.Descriptor instead. +func (*RegisterActorReminderRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{33} +} + +func (x *RegisterActorReminderRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *RegisterActorReminderRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *RegisterActorReminderRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *RegisterActorReminderRequest) GetDueTime() string { + if x != nil { + return x.DueTime + } + return "" +} + +func (x *RegisterActorReminderRequest) GetPeriod() string { + if x != nil { + return x.Period + } + return "" +} + +func (x *RegisterActorReminderRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *RegisterActorReminderRequest) GetTtl() string { + if x != nil { + return x.Ttl + } + return "" +} + +// UnregisterActorReminderRequest is the message to unregister an actor reminder. +type UnregisterActorReminderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnregisterActorReminderRequest) Reset() { + *x = UnregisterActorReminderRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnregisterActorReminderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnregisterActorReminderRequest) ProtoMessage() {} + +func (x *UnregisterActorReminderRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnregisterActorReminderRequest.ProtoReflect.Descriptor instead. +func (*UnregisterActorReminderRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{34} +} + +func (x *UnregisterActorReminderRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *UnregisterActorReminderRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *UnregisterActorReminderRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// GetActorStateRequest is the message to get key-value states from specific actor. +type GetActorStateRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Key string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetActorStateRequest) Reset() { + *x = GetActorStateRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetActorStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActorStateRequest) ProtoMessage() {} + +func (x *GetActorStateRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActorStateRequest.ProtoReflect.Descriptor instead. +func (*GetActorStateRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{35} +} + +func (x *GetActorStateRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *GetActorStateRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *GetActorStateRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +// GetActorStateResponse is the response conveying the actor's state value. +type GetActorStateResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // The metadata which will be sent to app. + Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetActorStateResponse) Reset() { + *x = GetActorStateResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetActorStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActorStateResponse) ProtoMessage() {} + +func (x *GetActorStateResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[36] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActorStateResponse.ProtoReflect.Descriptor instead. +func (*GetActorStateResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{36} +} + +func (x *GetActorStateResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *GetActorStateResponse) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// ExecuteActorStateTransactionRequest is the message to execute multiple operations on a specified actor. +type ExecuteActorStateTransactionRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Operations []*TransactionalActorStateOperation `protobuf:"bytes,3,rep,name=operations,proto3" json:"operations,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExecuteActorStateTransactionRequest) Reset() { + *x = ExecuteActorStateTransactionRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecuteActorStateTransactionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecuteActorStateTransactionRequest) ProtoMessage() {} + +func (x *ExecuteActorStateTransactionRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[37] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecuteActorStateTransactionRequest.ProtoReflect.Descriptor instead. +func (*ExecuteActorStateTransactionRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{37} +} + +func (x *ExecuteActorStateTransactionRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *ExecuteActorStateTransactionRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *ExecuteActorStateTransactionRequest) GetOperations() []*TransactionalActorStateOperation { + if x != nil { + return x.Operations + } + return nil +} + +// TransactionalActorStateOperation is the message to execute a specified operation with a key-value pair. +type TransactionalActorStateOperation struct { + state protoimpl.MessageState `protogen:"open.v1"` + OperationType string `protobuf:"bytes,1,opt,name=operationType,proto3" json:"operationType,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value *anypb.Any `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + // The metadata used for transactional operations. + // + // Common metadata property: + // - ttlInSeconds : the time to live in seconds for the stored value. + Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TransactionalActorStateOperation) Reset() { + *x = TransactionalActorStateOperation{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TransactionalActorStateOperation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TransactionalActorStateOperation) ProtoMessage() {} + +func (x *TransactionalActorStateOperation) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[38] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TransactionalActorStateOperation.ProtoReflect.Descriptor instead. +func (*TransactionalActorStateOperation) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{38} +} + +func (x *TransactionalActorStateOperation) GetOperationType() string { + if x != nil { + return x.OperationType + } + return "" +} + +func (x *TransactionalActorStateOperation) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *TransactionalActorStateOperation) GetValue() *anypb.Any { + if x != nil { + return x.Value + } + return nil +} + +func (x *TransactionalActorStateOperation) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// InvokeActorRequest is the message to call an actor. +type InvokeActorRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"` + ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeActorRequest) Reset() { + *x = InvokeActorRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeActorRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeActorRequest) ProtoMessage() {} + +func (x *InvokeActorRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[39] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeActorRequest.ProtoReflect.Descriptor instead. +func (*InvokeActorRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{39} +} + +func (x *InvokeActorRequest) GetActorType() string { + if x != nil { + return x.ActorType + } + return "" +} + +func (x *InvokeActorRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *InvokeActorRequest) GetMethod() string { + if x != nil { + return x.Method + } + return "" +} + +func (x *InvokeActorRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *InvokeActorRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// InvokeActorResponse is the method that returns an actor invocation response. +type InvokeActorResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InvokeActorResponse) Reset() { + *x = InvokeActorResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InvokeActorResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InvokeActorResponse) ProtoMessage() {} + +func (x *InvokeActorResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[40] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InvokeActorResponse.ProtoReflect.Descriptor instead. +func (*InvokeActorResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{40} +} + +func (x *InvokeActorResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +// GetMetadataRequest is the message for the GetMetadata request. +type GetMetadataRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetMetadataRequest) Reset() { + *x = GetMetadataRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetMetadataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMetadataRequest) ProtoMessage() {} + +func (x *GetMetadataRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[41] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMetadataRequest.ProtoReflect.Descriptor instead. +func (*GetMetadataRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{41} +} + +// GetMetadataResponse is a message that is returned on GetMetadata rpc call. +type GetMetadataResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Deprecated alias for actor_runtime.active_actors. + // + // Deprecated: Marked as deprecated in dapr/proto/runtime/v1/dapr.proto. + ActiveActorsCount []*ActiveActorsCount `protobuf:"bytes,2,rep,name=active_actors_count,json=actors,proto3" json:"active_actors_count,omitempty"` + RegisteredComponents []*RegisteredComponents `protobuf:"bytes,3,rep,name=registered_components,json=components,proto3" json:"registered_components,omitempty"` + ExtendedMetadata map[string]string `protobuf:"bytes,4,rep,name=extended_metadata,json=extended,proto3" json:"extended_metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Subscriptions []*PubsubSubscription `protobuf:"bytes,5,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"` + HttpEndpoints []*MetadataHTTPEndpoint `protobuf:"bytes,6,rep,name=http_endpoints,json=httpEndpoints,proto3" json:"http_endpoints,omitempty"` + AppConnectionProperties *AppConnectionProperties `protobuf:"bytes,7,opt,name=app_connection_properties,json=appConnectionProperties,proto3" json:"app_connection_properties,omitempty"` + RuntimeVersion string `protobuf:"bytes,8,opt,name=runtime_version,json=runtimeVersion,proto3" json:"runtime_version,omitempty"` + EnabledFeatures []string `protobuf:"bytes,9,rep,name=enabled_features,json=enabledFeatures,proto3" json:"enabled_features,omitempty"` + ActorRuntime *ActorRuntime `protobuf:"bytes,10,opt,name=actor_runtime,json=actorRuntime,proto3" json:"actor_runtime,omitempty"` + Scheduler *MetadataScheduler `protobuf:"bytes,11,opt,name=scheduler,proto3,oneof" json:"scheduler,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetMetadataResponse) Reset() { + *x = GetMetadataResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetMetadataResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMetadataResponse) ProtoMessage() {} + +func (x *GetMetadataResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMetadataResponse.ProtoReflect.Descriptor instead. +func (*GetMetadataResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{42} +} + +func (x *GetMetadataResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +// Deprecated: Marked as deprecated in dapr/proto/runtime/v1/dapr.proto. +func (x *GetMetadataResponse) GetActiveActorsCount() []*ActiveActorsCount { + if x != nil { + return x.ActiveActorsCount + } + return nil +} + +func (x *GetMetadataResponse) GetRegisteredComponents() []*RegisteredComponents { + if x != nil { + return x.RegisteredComponents + } + return nil +} + +func (x *GetMetadataResponse) GetExtendedMetadata() map[string]string { + if x != nil { + return x.ExtendedMetadata + } + return nil +} + +func (x *GetMetadataResponse) GetSubscriptions() []*PubsubSubscription { + if x != nil { + return x.Subscriptions + } + return nil +} + +func (x *GetMetadataResponse) GetHttpEndpoints() []*MetadataHTTPEndpoint { + if x != nil { + return x.HttpEndpoints + } + return nil +} + +func (x *GetMetadataResponse) GetAppConnectionProperties() *AppConnectionProperties { + if x != nil { + return x.AppConnectionProperties + } + return nil +} + +func (x *GetMetadataResponse) GetRuntimeVersion() string { + if x != nil { + return x.RuntimeVersion + } + return "" +} + +func (x *GetMetadataResponse) GetEnabledFeatures() []string { + if x != nil { + return x.EnabledFeatures + } + return nil +} + +func (x *GetMetadataResponse) GetActorRuntime() *ActorRuntime { + if x != nil { + return x.ActorRuntime + } + return nil +} + +func (x *GetMetadataResponse) GetScheduler() *MetadataScheduler { + if x != nil { + return x.Scheduler + } + return nil +} + +// MetadataScheduler is a message that contains the list of addresses of the +// scheduler connections. +type MetadataScheduler struct { + state protoimpl.MessageState `protogen:"open.v1"` + // connected_addresses the list of addresses of the scheduler connections. + ConnectedAddresses []string `protobuf:"bytes,1,rep,name=connected_addresses,json=connectedAddresses,proto3" json:"connected_addresses,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MetadataScheduler) Reset() { + *x = MetadataScheduler{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MetadataScheduler) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MetadataScheduler) ProtoMessage() {} + +func (x *MetadataScheduler) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[43] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MetadataScheduler.ProtoReflect.Descriptor instead. +func (*MetadataScheduler) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{43} +} + +func (x *MetadataScheduler) GetConnectedAddresses() []string { + if x != nil { + return x.ConnectedAddresses + } + return nil +} + +type ActorRuntime struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Contains an enum indicating whether the actor runtime has been initialized. + RuntimeStatus ActorRuntime_ActorRuntimeStatus `protobuf:"varint,1,opt,name=runtime_status,json=runtimeStatus,proto3,enum=dapr.proto.runtime.v1.ActorRuntime_ActorRuntimeStatus" json:"runtime_status,omitempty"` + // Count of active actors per type. + ActiveActors []*ActiveActorsCount `protobuf:"bytes,2,rep,name=active_actors,json=activeActors,proto3" json:"active_actors,omitempty"` + // Indicates whether the actor runtime is ready to host actors. + HostReady bool `protobuf:"varint,3,opt,name=host_ready,json=hostReady,proto3" json:"host_ready,omitempty"` + // Custom message from the placement provider. + Placement string `protobuf:"bytes,4,opt,name=placement,proto3" json:"placement,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActorRuntime) Reset() { + *x = ActorRuntime{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActorRuntime) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActorRuntime) ProtoMessage() {} + +func (x *ActorRuntime) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[44] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActorRuntime.ProtoReflect.Descriptor instead. +func (*ActorRuntime) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{44} +} + +func (x *ActorRuntime) GetRuntimeStatus() ActorRuntime_ActorRuntimeStatus { + if x != nil { + return x.RuntimeStatus + } + return ActorRuntime_INITIALIZING +} + +func (x *ActorRuntime) GetActiveActors() []*ActiveActorsCount { + if x != nil { + return x.ActiveActors + } + return nil +} + +func (x *ActorRuntime) GetHostReady() bool { + if x != nil { + return x.HostReady + } + return false +} + +func (x *ActorRuntime) GetPlacement() string { + if x != nil { + return x.Placement + } + return "" +} + +type ActiveActorsCount struct { + state protoimpl.MessageState `protogen:"open.v1"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActiveActorsCount) Reset() { + *x = ActiveActorsCount{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActiveActorsCount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActiveActorsCount) ProtoMessage() {} + +func (x *ActiveActorsCount) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[45] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActiveActorsCount.ProtoReflect.Descriptor instead. +func (*ActiveActorsCount) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{45} +} + +func (x *ActiveActorsCount) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *ActiveActorsCount) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +type RegisteredComponents struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"` + Capabilities []string `protobuf:"bytes,4,rep,name=capabilities,proto3" json:"capabilities,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RegisteredComponents) Reset() { + *x = RegisteredComponents{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RegisteredComponents) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RegisteredComponents) ProtoMessage() {} + +func (x *RegisteredComponents) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[46] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RegisteredComponents.ProtoReflect.Descriptor instead. +func (*RegisteredComponents) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{46} +} + +func (x *RegisteredComponents) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *RegisteredComponents) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *RegisteredComponents) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *RegisteredComponents) GetCapabilities() []string { + if x != nil { + return x.Capabilities + } + return nil +} + +type MetadataHTTPEndpoint struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MetadataHTTPEndpoint) Reset() { + *x = MetadataHTTPEndpoint{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MetadataHTTPEndpoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MetadataHTTPEndpoint) ProtoMessage() {} + +func (x *MetadataHTTPEndpoint) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[47] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MetadataHTTPEndpoint.ProtoReflect.Descriptor instead. +func (*MetadataHTTPEndpoint) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{47} +} + +func (x *MetadataHTTPEndpoint) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type AppConnectionProperties struct { + state protoimpl.MessageState `protogen:"open.v1"` + Port int32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"` + Protocol string `protobuf:"bytes,2,opt,name=protocol,proto3" json:"protocol,omitempty"` + ChannelAddress string `protobuf:"bytes,3,opt,name=channel_address,json=channelAddress,proto3" json:"channel_address,omitempty"` + MaxConcurrency int32 `protobuf:"varint,4,opt,name=max_concurrency,json=maxConcurrency,proto3" json:"max_concurrency,omitempty"` + Health *AppConnectionHealthProperties `protobuf:"bytes,5,opt,name=health,proto3" json:"health,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppConnectionProperties) Reset() { + *x = AppConnectionProperties{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppConnectionProperties) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppConnectionProperties) ProtoMessage() {} + +func (x *AppConnectionProperties) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[48] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppConnectionProperties.ProtoReflect.Descriptor instead. +func (*AppConnectionProperties) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{48} +} + +func (x *AppConnectionProperties) GetPort() int32 { + if x != nil { + return x.Port + } + return 0 +} + +func (x *AppConnectionProperties) GetProtocol() string { + if x != nil { + return x.Protocol + } + return "" +} + +func (x *AppConnectionProperties) GetChannelAddress() string { + if x != nil { + return x.ChannelAddress + } + return "" +} + +func (x *AppConnectionProperties) GetMaxConcurrency() int32 { + if x != nil { + return x.MaxConcurrency + } + return 0 +} + +func (x *AppConnectionProperties) GetHealth() *AppConnectionHealthProperties { + if x != nil { + return x.Health + } + return nil +} + +type AppConnectionHealthProperties struct { + state protoimpl.MessageState `protogen:"open.v1"` + HealthCheckPath string `protobuf:"bytes,1,opt,name=health_check_path,json=healthCheckPath,proto3" json:"health_check_path,omitempty"` + HealthProbeInterval string `protobuf:"bytes,2,opt,name=health_probe_interval,json=healthProbeInterval,proto3" json:"health_probe_interval,omitempty"` + HealthProbeTimeout string `protobuf:"bytes,3,opt,name=health_probe_timeout,json=healthProbeTimeout,proto3" json:"health_probe_timeout,omitempty"` + HealthThreshold int32 `protobuf:"varint,4,opt,name=health_threshold,json=healthThreshold,proto3" json:"health_threshold,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppConnectionHealthProperties) Reset() { + *x = AppConnectionHealthProperties{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppConnectionHealthProperties) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppConnectionHealthProperties) ProtoMessage() {} + +func (x *AppConnectionHealthProperties) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[49] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppConnectionHealthProperties.ProtoReflect.Descriptor instead. +func (*AppConnectionHealthProperties) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{49} +} + +func (x *AppConnectionHealthProperties) GetHealthCheckPath() string { + if x != nil { + return x.HealthCheckPath + } + return "" +} + +func (x *AppConnectionHealthProperties) GetHealthProbeInterval() string { + if x != nil { + return x.HealthProbeInterval + } + return "" +} + +func (x *AppConnectionHealthProperties) GetHealthProbeTimeout() string { + if x != nil { + return x.HealthProbeTimeout + } + return "" +} + +func (x *AppConnectionHealthProperties) GetHealthThreshold() int32 { + if x != nil { + return x.HealthThreshold + } + return 0 +} + +type PubsubSubscription struct { + state protoimpl.MessageState `protogen:"open.v1"` + PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubname,proto3" json:"pubsub_name,omitempty"` + Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"` + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Rules *PubsubSubscriptionRules `protobuf:"bytes,4,opt,name=rules,proto3" json:"rules,omitempty"` + DeadLetterTopic string `protobuf:"bytes,5,opt,name=dead_letter_topic,json=deadLetterTopic,proto3" json:"dead_letter_topic,omitempty"` + Type PubsubSubscriptionType `protobuf:"varint,6,opt,name=type,proto3,enum=dapr.proto.runtime.v1.PubsubSubscriptionType" json:"type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PubsubSubscription) Reset() { + *x = PubsubSubscription{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PubsubSubscription) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PubsubSubscription) ProtoMessage() {} + +func (x *PubsubSubscription) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[50] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PubsubSubscription.ProtoReflect.Descriptor instead. +func (*PubsubSubscription) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{50} +} + +func (x *PubsubSubscription) GetPubsubName() string { + if x != nil { + return x.PubsubName + } + return "" +} + +func (x *PubsubSubscription) GetTopic() string { + if x != nil { + return x.Topic + } + return "" +} + +func (x *PubsubSubscription) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *PubsubSubscription) GetRules() *PubsubSubscriptionRules { + if x != nil { + return x.Rules + } + return nil +} + +func (x *PubsubSubscription) GetDeadLetterTopic() string { + if x != nil { + return x.DeadLetterTopic + } + return "" +} + +func (x *PubsubSubscription) GetType() PubsubSubscriptionType { + if x != nil { + return x.Type + } + return PubsubSubscriptionType_UNKNOWN +} + +type PubsubSubscriptionRules struct { + state protoimpl.MessageState `protogen:"open.v1"` + Rules []*PubsubSubscriptionRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PubsubSubscriptionRules) Reset() { + *x = PubsubSubscriptionRules{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PubsubSubscriptionRules) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PubsubSubscriptionRules) ProtoMessage() {} + +func (x *PubsubSubscriptionRules) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[51] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PubsubSubscriptionRules.ProtoReflect.Descriptor instead. +func (*PubsubSubscriptionRules) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{51} +} + +func (x *PubsubSubscriptionRules) GetRules() []*PubsubSubscriptionRule { + if x != nil { + return x.Rules + } + return nil +} + +type PubsubSubscriptionRule struct { + state protoimpl.MessageState `protogen:"open.v1"` + Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"` + Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PubsubSubscriptionRule) Reset() { + *x = PubsubSubscriptionRule{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PubsubSubscriptionRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PubsubSubscriptionRule) ProtoMessage() {} + +func (x *PubsubSubscriptionRule) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[52] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PubsubSubscriptionRule.ProtoReflect.Descriptor instead. +func (*PubsubSubscriptionRule) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{52} +} + +func (x *PubsubSubscriptionRule) GetMatch() string { + if x != nil { + return x.Match + } + return "" +} + +func (x *PubsubSubscriptionRule) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +type SetMetadataRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetMetadataRequest) Reset() { + *x = SetMetadataRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetMetadataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetMetadataRequest) ProtoMessage() {} + +func (x *SetMetadataRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[53] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetMetadataRequest.ProtoReflect.Descriptor instead. +func (*SetMetadataRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{53} +} + +func (x *SetMetadataRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SetMetadataRequest) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +// GetConfigurationRequest is the message to get a list of key-value configuration from specified configuration store. +type GetConfigurationRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The name of configuration store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // Optional. The key of the configuration item to fetch. + // If set, only query for the specified configuration items. + // Empty list means fetch all. + Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + // Optional. The metadata which will be sent to configuration store components. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetConfigurationRequest) Reset() { + *x = GetConfigurationRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetConfigurationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConfigurationRequest) ProtoMessage() {} + +func (x *GetConfigurationRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[54] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetConfigurationRequest.ProtoReflect.Descriptor instead. +func (*GetConfigurationRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{54} +} + +func (x *GetConfigurationRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *GetConfigurationRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +func (x *GetConfigurationRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// GetConfigurationResponse is the response conveying the list of configuration values. +// It should be the FULL configuration of specified application which contains all of its configuration items. +type GetConfigurationResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Items map[string]*v1.ConfigurationItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetConfigurationResponse) Reset() { + *x = GetConfigurationResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetConfigurationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetConfigurationResponse) ProtoMessage() {} + +func (x *GetConfigurationResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[55] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetConfigurationResponse.ProtoReflect.Descriptor instead. +func (*GetConfigurationResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{55} +} + +func (x *GetConfigurationResponse) GetItems() map[string]*v1.ConfigurationItem { + if x != nil { + return x.Items + } + return nil +} + +// SubscribeConfigurationRequest is the message to get a list of key-value configuration from specified configuration store. +type SubscribeConfigurationRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of configuration store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // Optional. The key of the configuration item to fetch. + // If set, only query for the specified configuration items. + // Empty list means fetch all. + Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + // The metadata which will be sent to configuration store components. + Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeConfigurationRequest) Reset() { + *x = SubscribeConfigurationRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeConfigurationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeConfigurationRequest) ProtoMessage() {} + +func (x *SubscribeConfigurationRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[56] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeConfigurationRequest.ProtoReflect.Descriptor instead. +func (*SubscribeConfigurationRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{56} +} + +func (x *SubscribeConfigurationRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *SubscribeConfigurationRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +func (x *SubscribeConfigurationRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +// UnSubscribeConfigurationRequest is the message to stop watching the key-value configuration. +type UnsubscribeConfigurationRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of configuration store. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // The id to unsubscribe. + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnsubscribeConfigurationRequest) Reset() { + *x = UnsubscribeConfigurationRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnsubscribeConfigurationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnsubscribeConfigurationRequest) ProtoMessage() {} + +func (x *UnsubscribeConfigurationRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[57] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnsubscribeConfigurationRequest.ProtoReflect.Descriptor instead. +func (*UnsubscribeConfigurationRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{57} +} + +func (x *UnsubscribeConfigurationRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *UnsubscribeConfigurationRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type SubscribeConfigurationResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Subscribe id, used to stop subscription. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // The list of items containing configuration values + Items map[string]*v1.ConfigurationItem `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubscribeConfigurationResponse) Reset() { + *x = SubscribeConfigurationResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubscribeConfigurationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubscribeConfigurationResponse) ProtoMessage() {} + +func (x *SubscribeConfigurationResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[58] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubscribeConfigurationResponse.ProtoReflect.Descriptor instead. +func (*SubscribeConfigurationResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{58} +} + +func (x *SubscribeConfigurationResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *SubscribeConfigurationResponse) GetItems() map[string]*v1.ConfigurationItem { + if x != nil { + return x.Items + } + return nil +} + +type UnsubscribeConfigurationResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnsubscribeConfigurationResponse) Reset() { + *x = UnsubscribeConfigurationResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnsubscribeConfigurationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnsubscribeConfigurationResponse) ProtoMessage() {} + +func (x *UnsubscribeConfigurationResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[59] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnsubscribeConfigurationResponse.ProtoReflect.Descriptor instead. +func (*UnsubscribeConfigurationResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{59} +} + +func (x *UnsubscribeConfigurationResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +func (x *UnsubscribeConfigurationResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type TryLockRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The lock store name,e.g. `redis`. + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // Required. resource_id is the lock key. e.g. `order_id_111` + // It stands for "which resource I want to protect" + ResourceId string `protobuf:"bytes,2,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"` + // Required. lock_owner indicate the identifier of lock owner. + // You can generate a uuid as lock_owner.For example,in golang: + // + // req.LockOwner = uuid.New().String() + // + // This field is per request,not per process,so it is different for each request, + // which aims to prevent multi-thread in the same process trying the same lock concurrently. + // + // The reason why we don't make it automatically generated is: + // 1. If it is automatically generated,there must be a 'my_lock_owner_id' field in the response. + // This name is so weird that we think it is inappropriate to put it into the api spec + // 2. If we change the field 'my_lock_owner_id' in the response to 'lock_owner',which means the current lock owner of this lock, + // we find that in some lock services users can't get the current lock owner.Actually users don't need it at all. + // 3. When reentrant lock is needed,the existing lock_owner is required to identify client and check "whether this client can reenter this lock". + // So this field in the request shouldn't be removed. + LockOwner string `protobuf:"bytes,3,opt,name=lock_owner,json=lockOwner,proto3" json:"lock_owner,omitempty"` + // Required. The time before expiry.The time unit is second. + ExpiryInSeconds int32 `protobuf:"varint,4,opt,name=expiry_in_seconds,json=expiryInSeconds,proto3" json:"expiry_in_seconds,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TryLockRequest) Reset() { + *x = TryLockRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[60] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TryLockRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TryLockRequest) ProtoMessage() {} + +func (x *TryLockRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[60] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TryLockRequest.ProtoReflect.Descriptor instead. +func (*TryLockRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{60} +} + +func (x *TryLockRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *TryLockRequest) GetResourceId() string { + if x != nil { + return x.ResourceId + } + return "" +} + +func (x *TryLockRequest) GetLockOwner() string { + if x != nil { + return x.LockOwner + } + return "" +} + +func (x *TryLockRequest) GetExpiryInSeconds() int32 { + if x != nil { + return x.ExpiryInSeconds + } + return 0 +} + +type TryLockResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TryLockResponse) Reset() { + *x = TryLockResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[61] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TryLockResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TryLockResponse) ProtoMessage() {} + +func (x *TryLockResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[61] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TryLockResponse.ProtoReflect.Descriptor instead. +func (*TryLockResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{61} +} + +func (x *TryLockResponse) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +type UnlockRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"` + // resource_id is the lock key. + ResourceId string `protobuf:"bytes,2,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"` + LockOwner string `protobuf:"bytes,3,opt,name=lock_owner,json=lockOwner,proto3" json:"lock_owner,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnlockRequest) Reset() { + *x = UnlockRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnlockRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnlockRequest) ProtoMessage() {} + +func (x *UnlockRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[62] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnlockRequest.ProtoReflect.Descriptor instead. +func (*UnlockRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{62} +} + +func (x *UnlockRequest) GetStoreName() string { + if x != nil { + return x.StoreName + } + return "" +} + +func (x *UnlockRequest) GetResourceId() string { + if x != nil { + return x.ResourceId + } + return "" +} + +func (x *UnlockRequest) GetLockOwner() string { + if x != nil { + return x.LockOwner + } + return "" +} + +type UnlockResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Status UnlockResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=dapr.proto.runtime.v1.UnlockResponse_Status" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnlockResponse) Reset() { + *x = UnlockResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[63] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnlockResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnlockResponse) ProtoMessage() {} + +func (x *UnlockResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[63] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnlockResponse.ProtoReflect.Descriptor instead. +func (*UnlockResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{63} +} + +func (x *UnlockResponse) GetStatus() UnlockResponse_Status { + if x != nil { + return x.Status + } + return UnlockResponse_SUCCESS +} + +// SubtleGetKeyRequest is the request object for SubtleGetKeyAlpha1. +type SubtleGetKeyRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Name (or name/version) of the key to use in the key vault + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // Response format + Format SubtleGetKeyRequest_KeyFormat `protobuf:"varint,3,opt,name=format,proto3,enum=dapr.proto.runtime.v1.SubtleGetKeyRequest_KeyFormat" json:"format,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleGetKeyRequest) Reset() { + *x = SubtleGetKeyRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[64] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleGetKeyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleGetKeyRequest) ProtoMessage() {} + +func (x *SubtleGetKeyRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[64] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleGetKeyRequest.ProtoReflect.Descriptor instead. +func (*SubtleGetKeyRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{64} +} + +func (x *SubtleGetKeyRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleGetKeyRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SubtleGetKeyRequest) GetFormat() SubtleGetKeyRequest_KeyFormat { + if x != nil { + return x.Format + } + return SubtleGetKeyRequest_PEM +} + +// SubtleGetKeyResponse is the response for SubtleGetKeyAlpha1. +type SubtleGetKeyResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name (or name/version) of the key. + // This is returned as response too in case there is a version. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Public key, encoded in the requested format + PublicKey string `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleGetKeyResponse) Reset() { + *x = SubtleGetKeyResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[65] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleGetKeyResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleGetKeyResponse) ProtoMessage() {} + +func (x *SubtleGetKeyResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[65] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleGetKeyResponse.ProtoReflect.Descriptor instead. +func (*SubtleGetKeyResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{65} +} + +func (x *SubtleGetKeyResponse) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SubtleGetKeyResponse) GetPublicKey() string { + if x != nil { + return x.PublicKey + } + return "" +} + +// SubtleEncryptRequest is the request for SubtleEncryptAlpha1. +type SubtleEncryptRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Message to encrypt. + Plaintext []byte `protobuf:"bytes,2,opt,name=plaintext,proto3" json:"plaintext,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Nonce / initialization vector. + // Ignored with asymmetric ciphers. + Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"` + // Associated Data when using AEAD ciphers (optional). + AssociatedData []byte `protobuf:"bytes,6,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleEncryptRequest) Reset() { + *x = SubtleEncryptRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[66] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleEncryptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleEncryptRequest) ProtoMessage() {} + +func (x *SubtleEncryptRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[66] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleEncryptRequest.ProtoReflect.Descriptor instead. +func (*SubtleEncryptRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{66} +} + +func (x *SubtleEncryptRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleEncryptRequest) GetPlaintext() []byte { + if x != nil { + return x.Plaintext + } + return nil +} + +func (x *SubtleEncryptRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleEncryptRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *SubtleEncryptRequest) GetNonce() []byte { + if x != nil { + return x.Nonce + } + return nil +} + +func (x *SubtleEncryptRequest) GetAssociatedData() []byte { + if x != nil { + return x.AssociatedData + } + return nil +} + +// SubtleEncryptResponse is the response for SubtleEncryptAlpha1. +type SubtleEncryptResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Encrypted ciphertext. + Ciphertext []byte `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` + // Authentication tag. + // This is nil when not using an authenticated cipher. + Tag []byte `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleEncryptResponse) Reset() { + *x = SubtleEncryptResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[67] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleEncryptResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleEncryptResponse) ProtoMessage() {} + +func (x *SubtleEncryptResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[67] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleEncryptResponse.ProtoReflect.Descriptor instead. +func (*SubtleEncryptResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{67} +} + +func (x *SubtleEncryptResponse) GetCiphertext() []byte { + if x != nil { + return x.Ciphertext + } + return nil +} + +func (x *SubtleEncryptResponse) GetTag() []byte { + if x != nil { + return x.Tag + } + return nil +} + +// SubtleDecryptRequest is the request for SubtleDecryptAlpha1. +type SubtleDecryptRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Message to decrypt. + Ciphertext []byte `protobuf:"bytes,2,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Nonce / initialization vector. + // Ignored with asymmetric ciphers. + Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"` + // Authentication tag. + // This is nil when not using an authenticated cipher. + Tag []byte `protobuf:"bytes,6,opt,name=tag,proto3" json:"tag,omitempty"` + // Associated Data when using AEAD ciphers (optional). + AssociatedData []byte `protobuf:"bytes,7,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleDecryptRequest) Reset() { + *x = SubtleDecryptRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[68] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleDecryptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleDecryptRequest) ProtoMessage() {} + +func (x *SubtleDecryptRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[68] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleDecryptRequest.ProtoReflect.Descriptor instead. +func (*SubtleDecryptRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{68} +} + +func (x *SubtleDecryptRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleDecryptRequest) GetCiphertext() []byte { + if x != nil { + return x.Ciphertext + } + return nil +} + +func (x *SubtleDecryptRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleDecryptRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *SubtleDecryptRequest) GetNonce() []byte { + if x != nil { + return x.Nonce + } + return nil +} + +func (x *SubtleDecryptRequest) GetTag() []byte { + if x != nil { + return x.Tag + } + return nil +} + +func (x *SubtleDecryptRequest) GetAssociatedData() []byte { + if x != nil { + return x.AssociatedData + } + return nil +} + +// SubtleDecryptResponse is the response for SubtleDecryptAlpha1. +type SubtleDecryptResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Decrypted plaintext. + Plaintext []byte `protobuf:"bytes,1,opt,name=plaintext,proto3" json:"plaintext,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleDecryptResponse) Reset() { + *x = SubtleDecryptResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[69] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleDecryptResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleDecryptResponse) ProtoMessage() {} + +func (x *SubtleDecryptResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[69] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleDecryptResponse.ProtoReflect.Descriptor instead. +func (*SubtleDecryptResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{69} +} + +func (x *SubtleDecryptResponse) GetPlaintext() []byte { + if x != nil { + return x.Plaintext + } + return nil +} + +// SubtleWrapKeyRequest is the request for SubtleWrapKeyAlpha1. +type SubtleWrapKeyRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Key to wrap + PlaintextKey []byte `protobuf:"bytes,2,opt,name=plaintext_key,json=plaintextKey,proto3" json:"plaintext_key,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Nonce / initialization vector. + // Ignored with asymmetric ciphers. + Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"` + // Associated Data when using AEAD ciphers (optional). + AssociatedData []byte `protobuf:"bytes,6,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleWrapKeyRequest) Reset() { + *x = SubtleWrapKeyRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[70] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleWrapKeyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleWrapKeyRequest) ProtoMessage() {} + +func (x *SubtleWrapKeyRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[70] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleWrapKeyRequest.ProtoReflect.Descriptor instead. +func (*SubtleWrapKeyRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{70} +} + +func (x *SubtleWrapKeyRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleWrapKeyRequest) GetPlaintextKey() []byte { + if x != nil { + return x.PlaintextKey + } + return nil +} + +func (x *SubtleWrapKeyRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleWrapKeyRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *SubtleWrapKeyRequest) GetNonce() []byte { + if x != nil { + return x.Nonce + } + return nil +} + +func (x *SubtleWrapKeyRequest) GetAssociatedData() []byte { + if x != nil { + return x.AssociatedData + } + return nil +} + +// SubtleWrapKeyResponse is the response for SubtleWrapKeyAlpha1. +type SubtleWrapKeyResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Wrapped key. + WrappedKey []byte `protobuf:"bytes,1,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty"` + // Authentication tag. + // This is nil when not using an authenticated cipher. + Tag []byte `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleWrapKeyResponse) Reset() { + *x = SubtleWrapKeyResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[71] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleWrapKeyResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleWrapKeyResponse) ProtoMessage() {} + +func (x *SubtleWrapKeyResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[71] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleWrapKeyResponse.ProtoReflect.Descriptor instead. +func (*SubtleWrapKeyResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{71} +} + +func (x *SubtleWrapKeyResponse) GetWrappedKey() []byte { + if x != nil { + return x.WrappedKey + } + return nil +} + +func (x *SubtleWrapKeyResponse) GetTag() []byte { + if x != nil { + return x.Tag + } + return nil +} + +// SubtleUnwrapKeyRequest is the request for SubtleUnwrapKeyAlpha1. +type SubtleUnwrapKeyRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Wrapped key. + WrappedKey []byte `protobuf:"bytes,2,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Nonce / initialization vector. + // Ignored with asymmetric ciphers. + Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"` + // Authentication tag. + // This is nil when not using an authenticated cipher. + Tag []byte `protobuf:"bytes,6,opt,name=tag,proto3" json:"tag,omitempty"` + // Associated Data when using AEAD ciphers (optional). + AssociatedData []byte `protobuf:"bytes,7,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleUnwrapKeyRequest) Reset() { + *x = SubtleUnwrapKeyRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleUnwrapKeyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleUnwrapKeyRequest) ProtoMessage() {} + +func (x *SubtleUnwrapKeyRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[72] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleUnwrapKeyRequest.ProtoReflect.Descriptor instead. +func (*SubtleUnwrapKeyRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{72} +} + +func (x *SubtleUnwrapKeyRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleUnwrapKeyRequest) GetWrappedKey() []byte { + if x != nil { + return x.WrappedKey + } + return nil +} + +func (x *SubtleUnwrapKeyRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleUnwrapKeyRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *SubtleUnwrapKeyRequest) GetNonce() []byte { + if x != nil { + return x.Nonce + } + return nil +} + +func (x *SubtleUnwrapKeyRequest) GetTag() []byte { + if x != nil { + return x.Tag + } + return nil +} + +func (x *SubtleUnwrapKeyRequest) GetAssociatedData() []byte { + if x != nil { + return x.AssociatedData + } + return nil +} + +// SubtleUnwrapKeyResponse is the response for SubtleUnwrapKeyAlpha1. +type SubtleUnwrapKeyResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Key in plaintext + PlaintextKey []byte `protobuf:"bytes,1,opt,name=plaintext_key,json=plaintextKey,proto3" json:"plaintext_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleUnwrapKeyResponse) Reset() { + *x = SubtleUnwrapKeyResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[73] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleUnwrapKeyResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleUnwrapKeyResponse) ProtoMessage() {} + +func (x *SubtleUnwrapKeyResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[73] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleUnwrapKeyResponse.ProtoReflect.Descriptor instead. +func (*SubtleUnwrapKeyResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{73} +} + +func (x *SubtleUnwrapKeyResponse) GetPlaintextKey() []byte { + if x != nil { + return x.PlaintextKey + } + return nil +} + +// SubtleSignRequest is the request for SubtleSignAlpha1. +type SubtleSignRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Digest to sign. + Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleSignRequest) Reset() { + *x = SubtleSignRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[74] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleSignRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleSignRequest) ProtoMessage() {} + +func (x *SubtleSignRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[74] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleSignRequest.ProtoReflect.Descriptor instead. +func (*SubtleSignRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{74} +} + +func (x *SubtleSignRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleSignRequest) GetDigest() []byte { + if x != nil { + return x.Digest + } + return nil +} + +func (x *SubtleSignRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleSignRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +// SubtleSignResponse is the response for SubtleSignAlpha1. +type SubtleSignResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The signature that was computed + Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleSignResponse) Reset() { + *x = SubtleSignResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[75] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleSignResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleSignResponse) ProtoMessage() {} + +func (x *SubtleSignResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[75] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleSignResponse.ProtoReflect.Descriptor instead. +func (*SubtleSignResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{75} +} + +func (x *SubtleSignResponse) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +// SubtleVerifyRequest is the request for SubtleVerifyAlpha1. +type SubtleVerifyRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Digest of the message. + Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"` + // Algorithm to use, as in the JWA standard. + Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"` + // Name (or name/version) of the key. + KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Signature to verify. + Signature []byte `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleVerifyRequest) Reset() { + *x = SubtleVerifyRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[76] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleVerifyRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleVerifyRequest) ProtoMessage() {} + +func (x *SubtleVerifyRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[76] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleVerifyRequest.ProtoReflect.Descriptor instead. +func (*SubtleVerifyRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{76} +} + +func (x *SubtleVerifyRequest) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *SubtleVerifyRequest) GetDigest() []byte { + if x != nil { + return x.Digest + } + return nil +} + +func (x *SubtleVerifyRequest) GetAlgorithm() string { + if x != nil { + return x.Algorithm + } + return "" +} + +func (x *SubtleVerifyRequest) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *SubtleVerifyRequest) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +// SubtleVerifyResponse is the response for SubtleVerifyAlpha1. +type SubtleVerifyResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // True if the signature is valid. + Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SubtleVerifyResponse) Reset() { + *x = SubtleVerifyResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[77] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SubtleVerifyResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SubtleVerifyResponse) ProtoMessage() {} + +func (x *SubtleVerifyResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[77] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SubtleVerifyResponse.ProtoReflect.Descriptor instead. +func (*SubtleVerifyResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{77} +} + +func (x *SubtleVerifyResponse) GetValid() bool { + if x != nil { + return x.Valid + } + return false +} + +// EncryptRequest is the request for EncryptAlpha1. +type EncryptRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Request details. Must be present in the first message only. + Options *EncryptRequestOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"` + // Chunk of data of arbitrary size. + Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EncryptRequest) Reset() { + *x = EncryptRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[78] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EncryptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EncryptRequest) ProtoMessage() {} + +func (x *EncryptRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[78] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EncryptRequest.ProtoReflect.Descriptor instead. +func (*EncryptRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{78} +} + +func (x *EncryptRequest) GetOptions() *EncryptRequestOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *EncryptRequest) GetPayload() *v1.StreamPayload { + if x != nil { + return x.Payload + } + return nil +} + +// EncryptRequestOptions contains options for the first message in the EncryptAlpha1 request. +type EncryptRequestOptions struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component. Required. + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Name (or name/version) of the key. Required. + KeyName string `protobuf:"bytes,2,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + // Key wrapping algorithm to use. Required. + // Supported options include: A256KW (alias: AES), A128CBC, A192CBC, A256CBC, RSA-OAEP-256 (alias: RSA). + KeyWrapAlgorithm string `protobuf:"bytes,3,opt,name=key_wrap_algorithm,json=keyWrapAlgorithm,proto3" json:"key_wrap_algorithm,omitempty"` + // Cipher used to encrypt data (optional): "aes-gcm" (default) or "chacha20-poly1305" + DataEncryptionCipher string `protobuf:"bytes,10,opt,name=data_encryption_cipher,json=dataEncryptionCipher,proto3" json:"data_encryption_cipher,omitempty"` + // If true, the encrypted document does not contain a key reference. + // In that case, calls to the Decrypt method must provide a key reference (name or name/version). + // Defaults to false. + OmitDecryptionKeyName bool `protobuf:"varint,11,opt,name=omit_decryption_key_name,json=omitDecryptionKeyName,proto3" json:"omit_decryption_key_name,omitempty"` + // Key reference to embed in the encrypted document (name or name/version). + // This is helpful if the reference of the key used to decrypt the document is different from the one used to encrypt it. + // If unset, uses the reference of the key used to encrypt the document (this is the default behavior). + // This option is ignored if omit_decryption_key_name is true. + DecryptionKeyName string `protobuf:"bytes,12,opt,name=decryption_key_name,json=decryptionKeyName,proto3" json:"decryption_key_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EncryptRequestOptions) Reset() { + *x = EncryptRequestOptions{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[79] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EncryptRequestOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EncryptRequestOptions) ProtoMessage() {} + +func (x *EncryptRequestOptions) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[79] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EncryptRequestOptions.ProtoReflect.Descriptor instead. +func (*EncryptRequestOptions) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{79} +} + +func (x *EncryptRequestOptions) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *EncryptRequestOptions) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +func (x *EncryptRequestOptions) GetKeyWrapAlgorithm() string { + if x != nil { + return x.KeyWrapAlgorithm + } + return "" +} + +func (x *EncryptRequestOptions) GetDataEncryptionCipher() string { + if x != nil { + return x.DataEncryptionCipher + } + return "" +} + +func (x *EncryptRequestOptions) GetOmitDecryptionKeyName() bool { + if x != nil { + return x.OmitDecryptionKeyName + } + return false +} + +func (x *EncryptRequestOptions) GetDecryptionKeyName() string { + if x != nil { + return x.DecryptionKeyName + } + return "" +} + +// EncryptResponse is the response for EncryptAlpha1. +type EncryptResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Chunk of data. + Payload *v1.StreamPayload `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EncryptResponse) Reset() { + *x = EncryptResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[80] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EncryptResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EncryptResponse) ProtoMessage() {} + +func (x *EncryptResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[80] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EncryptResponse.ProtoReflect.Descriptor instead. +func (*EncryptResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{80} +} + +func (x *EncryptResponse) GetPayload() *v1.StreamPayload { + if x != nil { + return x.Payload + } + return nil +} + +// DecryptRequest is the request for DecryptAlpha1. +type DecryptRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Request details. Must be present in the first message only. + Options *DecryptRequestOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"` + // Chunk of data of arbitrary size. + Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DecryptRequest) Reset() { + *x = DecryptRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DecryptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DecryptRequest) ProtoMessage() {} + +func (x *DecryptRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[81] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DecryptRequest.ProtoReflect.Descriptor instead. +func (*DecryptRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{81} +} + +func (x *DecryptRequest) GetOptions() *DecryptRequestOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *DecryptRequest) GetPayload() *v1.StreamPayload { + if x != nil { + return x.Payload + } + return nil +} + +// DecryptRequestOptions contains options for the first message in the DecryptAlpha1 request. +type DecryptRequestOptions struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Name of the component + ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"` + // Name (or name/version) of the key to decrypt the message. + // Overrides any key reference included in the message if present. + // This is required if the message doesn't include a key reference (i.e. was created with omit_decryption_key_name set to true). + KeyName string `protobuf:"bytes,12,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DecryptRequestOptions) Reset() { + *x = DecryptRequestOptions{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DecryptRequestOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DecryptRequestOptions) ProtoMessage() {} + +func (x *DecryptRequestOptions) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[82] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DecryptRequestOptions.ProtoReflect.Descriptor instead. +func (*DecryptRequestOptions) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{82} +} + +func (x *DecryptRequestOptions) GetComponentName() string { + if x != nil { + return x.ComponentName + } + return "" +} + +func (x *DecryptRequestOptions) GetKeyName() string { + if x != nil { + return x.KeyName + } + return "" +} + +// DecryptResponse is the response for DecryptAlpha1. +type DecryptResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Chunk of data. + Payload *v1.StreamPayload `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DecryptResponse) Reset() { + *x = DecryptResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[83] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DecryptResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DecryptResponse) ProtoMessage() {} + +func (x *DecryptResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[83] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DecryptResponse.ProtoReflect.Descriptor instead. +func (*DecryptResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{83} +} + +func (x *DecryptResponse) GetPayload() *v1.StreamPayload { + if x != nil { + return x.Payload + } + return nil +} + +// GetWorkflowRequest is the request for GetWorkflowBeta1. +type GetWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to query. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetWorkflowRequest) Reset() { + *x = GetWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[84] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkflowRequest) ProtoMessage() {} + +func (x *GetWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[84] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetWorkflowRequest.ProtoReflect.Descriptor instead. +func (*GetWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{84} +} + +func (x *GetWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *GetWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +// GetWorkflowResponse is the response for GetWorkflowBeta1. +type GetWorkflowResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow. + WorkflowName string `protobuf:"bytes,2,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty"` + // The time at which the workflow instance was created. + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + // The last time at which the workflow instance had its state changed. + LastUpdatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_updated_at,json=lastUpdatedAt,proto3" json:"last_updated_at,omitempty"` + // The current status of the workflow instance, for example, "PENDING", "RUNNING", "SUSPENDED", "COMPLETED", "FAILED", and "TERMINATED". + RuntimeStatus string `protobuf:"bytes,5,opt,name=runtime_status,json=runtimeStatus,proto3" json:"runtime_status,omitempty"` + // Additional component-specific properties of the workflow instance. + Properties map[string]string `protobuf:"bytes,6,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetWorkflowResponse) Reset() { + *x = GetWorkflowResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[85] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetWorkflowResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkflowResponse) ProtoMessage() {} + +func (x *GetWorkflowResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[85] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetWorkflowResponse.ProtoReflect.Descriptor instead. +func (*GetWorkflowResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{85} +} + +func (x *GetWorkflowResponse) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *GetWorkflowResponse) GetWorkflowName() string { + if x != nil { + return x.WorkflowName + } + return "" +} + +func (x *GetWorkflowResponse) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *GetWorkflowResponse) GetLastUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.LastUpdatedAt + } + return nil +} + +func (x *GetWorkflowResponse) GetRuntimeStatus() string { + if x != nil { + return x.RuntimeStatus + } + return "" +} + +func (x *GetWorkflowResponse) GetProperties() map[string]string { + if x != nil { + return x.Properties + } + return nil +} + +// StartWorkflowRequest is the request for StartWorkflowBeta1. +type StartWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The ID to assign to the started workflow instance. If empty, a random ID is generated. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + // Name of the workflow. + WorkflowName string `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty"` + // Additional component-specific options for starting the workflow instance. + Options map[string]string `protobuf:"bytes,4,rep,name=options,proto3" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Input data for the workflow instance. + Input []byte `protobuf:"bytes,5,opt,name=input,proto3" json:"input,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StartWorkflowRequest) Reset() { + *x = StartWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[86] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StartWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StartWorkflowRequest) ProtoMessage() {} + +func (x *StartWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[86] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StartWorkflowRequest.ProtoReflect.Descriptor instead. +func (*StartWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{86} +} + +func (x *StartWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *StartWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +func (x *StartWorkflowRequest) GetWorkflowName() string { + if x != nil { + return x.WorkflowName + } + return "" +} + +func (x *StartWorkflowRequest) GetOptions() map[string]string { + if x != nil { + return x.Options + } + return nil +} + +func (x *StartWorkflowRequest) GetInput() []byte { + if x != nil { + return x.Input + } + return nil +} + +// StartWorkflowResponse is the response for StartWorkflowBeta1. +type StartWorkflowResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the started workflow instance. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StartWorkflowResponse) Reset() { + *x = StartWorkflowResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[87] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StartWorkflowResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StartWorkflowResponse) ProtoMessage() {} + +func (x *StartWorkflowResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[87] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StartWorkflowResponse.ProtoReflect.Descriptor instead. +func (*StartWorkflowResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{87} +} + +func (x *StartWorkflowResponse) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +// TerminateWorkflowRequest is the request for TerminateWorkflowBeta1. +type TerminateWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to terminate. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TerminateWorkflowRequest) Reset() { + *x = TerminateWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[88] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TerminateWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TerminateWorkflowRequest) ProtoMessage() {} + +func (x *TerminateWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[88] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TerminateWorkflowRequest.ProtoReflect.Descriptor instead. +func (*TerminateWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{88} +} + +func (x *TerminateWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *TerminateWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +// PauseWorkflowRequest is the request for PauseWorkflowBeta1. +type PauseWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to pause. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PauseWorkflowRequest) Reset() { + *x = PauseWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[89] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PauseWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PauseWorkflowRequest) ProtoMessage() {} + +func (x *PauseWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[89] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PauseWorkflowRequest.ProtoReflect.Descriptor instead. +func (*PauseWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{89} +} + +func (x *PauseWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *PauseWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +// ResumeWorkflowRequest is the request for ResumeWorkflowBeta1. +type ResumeWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to resume. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResumeWorkflowRequest) Reset() { + *x = ResumeWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResumeWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResumeWorkflowRequest) ProtoMessage() {} + +func (x *ResumeWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[90] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResumeWorkflowRequest.ProtoReflect.Descriptor instead. +func (*ResumeWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{90} +} + +func (x *ResumeWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *ResumeWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +// RaiseEventWorkflowRequest is the request for RaiseEventWorkflowBeta1. +type RaiseEventWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to raise an event for. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + // Name of the event. + EventName string `protobuf:"bytes,3,opt,name=event_name,json=eventName,proto3" json:"event_name,omitempty"` + // Data associated with the event. + EventData []byte `protobuf:"bytes,4,opt,name=event_data,json=eventData,proto3" json:"event_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RaiseEventWorkflowRequest) Reset() { + *x = RaiseEventWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[91] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RaiseEventWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RaiseEventWorkflowRequest) ProtoMessage() {} + +func (x *RaiseEventWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[91] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RaiseEventWorkflowRequest.ProtoReflect.Descriptor instead. +func (*RaiseEventWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{91} +} + +func (x *RaiseEventWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *RaiseEventWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +func (x *RaiseEventWorkflowRequest) GetEventName() string { + if x != nil { + return x.EventName + } + return "" +} + +func (x *RaiseEventWorkflowRequest) GetEventData() []byte { + if x != nil { + return x.EventData + } + return nil +} + +// PurgeWorkflowRequest is the request for PurgeWorkflowBeta1. +type PurgeWorkflowRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // ID of the workflow instance to purge. + InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"` + // Name of the workflow component. + WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PurgeWorkflowRequest) Reset() { + *x = PurgeWorkflowRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[92] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PurgeWorkflowRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PurgeWorkflowRequest) ProtoMessage() {} + +func (x *PurgeWorkflowRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[92] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PurgeWorkflowRequest.ProtoReflect.Descriptor instead. +func (*PurgeWorkflowRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{92} +} + +func (x *PurgeWorkflowRequest) GetInstanceId() string { + if x != nil { + return x.InstanceId + } + return "" +} + +func (x *PurgeWorkflowRequest) GetWorkflowComponent() string { + if x != nil { + return x.WorkflowComponent + } + return "" +} + +// ShutdownRequest is the request for Shutdown. +type ShutdownRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ShutdownRequest) Reset() { + *x = ShutdownRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[93] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ShutdownRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ShutdownRequest) ProtoMessage() {} + +func (x *ShutdownRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[93] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ShutdownRequest.ProtoReflect.Descriptor instead. +func (*ShutdownRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{93} +} + +// Job is the definition of a job. At least one of schedule or due_time must be +// provided but can also be provided together. +type Job struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The unique name for the job. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // schedule is an optional schedule at which the job is to be run. + // Accepts both systemd timer style cron expressions, as well as human + // readable '@' prefixed period strings as defined below. + // + // Systemd timer style cron accepts 6 fields: + // seconds | minutes | hours | day of month | month | day of week + // 0-59 | 0-59 | 0-23 | 1-31 | 1-12/jan-dec | 0-6/sun-sat + // + // "0 30 * * * *" - every hour on the half hour + // "0 15 3 * * *" - every day at 03:15 + // + // Period string expressions: + // Entry | Description | Equivalent To + // ----- | ----------- | ------------- + // @every `` | Run every `` (e.g. '@every 1h30m') | N/A + // @yearly (or @annually) | Run once a year, midnight, Jan. 1st | 0 0 0 1 1 * + // @monthly | Run once a month, midnight, first of month | 0 0 0 1 * * + // @weekly | Run once a week, midnight on Sunday | 0 0 0 * * 0 + // @daily (or @midnight) | Run once a day, midnight | 0 0 0 * * * + // @hourly | Run once an hour, beginning of hour | 0 0 * * * * + Schedule *string `protobuf:"bytes,2,opt,name=schedule,proto3,oneof" json:"schedule,omitempty"` + // repeats is the optional number of times in which the job should be + // triggered. If not set, the job will run indefinitely or until expiration. + Repeats *uint32 `protobuf:"varint,3,opt,name=repeats,proto3,oneof" json:"repeats,omitempty"` + // due_time is the optional time at which the job should be active, or the + // "one shot" time if other scheduling type fields are not provided. Accepts + // a "point in time" string in the format of RFC3339, Go duration string + // (calculated from job creation time), or non-repeating ISO8601. + DueTime *string `protobuf:"bytes,4,opt,name=due_time,json=dueTime,proto3,oneof" json:"due_time,omitempty"` + // ttl is the optional time to live or expiration of the job. Accepts a + // "point in time" string in the format of RFC3339, Go duration string + // (calculated from job creation time), or non-repeating ISO8601. + Ttl *string `protobuf:"bytes,5,opt,name=ttl,proto3,oneof" json:"ttl,omitempty"` + // payload is the serialized job payload that will be sent to the recipient + // when the job is triggered. + Data *anypb.Any `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` + // If true, allows this job to overwrite an existing job with the same name. + Overwrite bool `protobuf:"varint,7,opt,name=overwrite,proto3" json:"overwrite,omitempty"` + // failure_policy is the optional policy for handling job failures. + FailurePolicy *v1.JobFailurePolicy `protobuf:"bytes,8,opt,name=failure_policy,json=failurePolicy,proto3,oneof" json:"failure_policy,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Job) Reset() { + *x = Job{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[94] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Job) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Job) ProtoMessage() {} + +func (x *Job) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[94] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Job.ProtoReflect.Descriptor instead. +func (*Job) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{94} +} + +func (x *Job) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Job) GetSchedule() string { + if x != nil && x.Schedule != nil { + return *x.Schedule + } + return "" +} + +func (x *Job) GetRepeats() uint32 { + if x != nil && x.Repeats != nil { + return *x.Repeats + } + return 0 +} + +func (x *Job) GetDueTime() string { + if x != nil && x.DueTime != nil { + return *x.DueTime + } + return "" +} + +func (x *Job) GetTtl() string { + if x != nil && x.Ttl != nil { + return *x.Ttl + } + return "" +} + +func (x *Job) GetData() *anypb.Any { + if x != nil { + return x.Data + } + return nil +} + +func (x *Job) GetOverwrite() bool { + if x != nil { + return x.Overwrite + } + return false +} + +func (x *Job) GetFailurePolicy() *v1.JobFailurePolicy { + if x != nil { + return x.FailurePolicy + } + return nil +} + +// ScheduleJobRequest is the message to create/schedule the job. +type ScheduleJobRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The job details. + Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScheduleJobRequest) Reset() { + *x = ScheduleJobRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[95] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScheduleJobRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScheduleJobRequest) ProtoMessage() {} + +func (x *ScheduleJobRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[95] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScheduleJobRequest.ProtoReflect.Descriptor instead. +func (*ScheduleJobRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{95} +} + +func (x *ScheduleJobRequest) GetJob() *Job { + if x != nil { + return x.Job + } + return nil +} + +// ScheduleJobResponse is the message response to create/schedule the job. +type ScheduleJobResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScheduleJobResponse) Reset() { + *x = ScheduleJobResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[96] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScheduleJobResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScheduleJobResponse) ProtoMessage() {} + +func (x *ScheduleJobResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[96] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScheduleJobResponse.ProtoReflect.Descriptor instead. +func (*ScheduleJobResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{96} +} + +// GetJobRequest is the message to retrieve a job. +type GetJobRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the job. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetJobRequest) Reset() { + *x = GetJobRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[97] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetJobRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetJobRequest) ProtoMessage() {} + +func (x *GetJobRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[97] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetJobRequest.ProtoReflect.Descriptor instead. +func (*GetJobRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{97} +} + +func (x *GetJobRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// GetJobResponse is the message's response for a job retrieved. +type GetJobResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The job details. + Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetJobResponse) Reset() { + *x = GetJobResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[98] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetJobResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetJobResponse) ProtoMessage() {} + +func (x *GetJobResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[98] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetJobResponse.ProtoReflect.Descriptor instead. +func (*GetJobResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{98} +} + +func (x *GetJobResponse) GetJob() *Job { + if x != nil { + return x.Job + } + return nil +} + +// DeleteJobRequest is the message to delete the job by name. +type DeleteJobRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of the job. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteJobRequest) Reset() { + *x = DeleteJobRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[99] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteJobRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteJobRequest) ProtoMessage() {} + +func (x *DeleteJobRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[99] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteJobRequest.ProtoReflect.Descriptor instead. +func (*DeleteJobRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{99} +} + +func (x *DeleteJobRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// DeleteJobResponse is the message response to delete the job by name. +type DeleteJobResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteJobResponse) Reset() { + *x = DeleteJobResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[100] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteJobResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteJobResponse) ProtoMessage() {} + +func (x *DeleteJobResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[100] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteJobResponse.ProtoReflect.Descriptor instead. +func (*DeleteJobResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{100} +} + +// ConversationRequest is the request object for Conversation. +type ConversationRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The name of Conversation component + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // The ID of an existing chat (like in ChatGPT) + ContextID *string `protobuf:"bytes,2,opt,name=contextID,proto3,oneof" json:"contextID,omitempty"` + // Inputs for the conversation, support multiple input in one time. + Inputs []*ConversationInput `protobuf:"bytes,3,rep,name=inputs,proto3" json:"inputs,omitempty"` + // Parameters for all custom fields. + Parameters map[string]*anypb.Any `protobuf:"bytes,4,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The metadata passing to conversation components. + Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Scrub PII data that comes back from the LLM + ScrubPII *bool `protobuf:"varint,6,opt,name=scrubPII,proto3,oneof" json:"scrubPII,omitempty"` + // Temperature for the LLM to optimize for creativity or predictability + Temperature *float64 `protobuf:"fixed64,7,opt,name=temperature,proto3,oneof" json:"temperature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConversationRequest) Reset() { + *x = ConversationRequest{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[101] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConversationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConversationRequest) ProtoMessage() {} + +func (x *ConversationRequest) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[101] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConversationRequest.ProtoReflect.Descriptor instead. +func (*ConversationRequest) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{101} +} + +func (x *ConversationRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ConversationRequest) GetContextID() string { + if x != nil && x.ContextID != nil { + return *x.ContextID + } + return "" +} + +func (x *ConversationRequest) GetInputs() []*ConversationInput { + if x != nil { + return x.Inputs + } + return nil +} + +func (x *ConversationRequest) GetParameters() map[string]*anypb.Any { + if x != nil { + return x.Parameters + } + return nil +} + +func (x *ConversationRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *ConversationRequest) GetScrubPII() bool { + if x != nil && x.ScrubPII != nil { + return *x.ScrubPII + } + return false +} + +func (x *ConversationRequest) GetTemperature() float64 { + if x != nil && x.Temperature != nil { + return *x.Temperature + } + return 0 +} + +type ConversationInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The content to send to the llm + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + // The role to set for the message + Role *string `protobuf:"bytes,2,opt,name=role,proto3,oneof" json:"role,omitempty"` + // Scrub PII data that goes into the LLM + ScrubPII *bool `protobuf:"varint,3,opt,name=scrubPII,proto3,oneof" json:"scrubPII,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConversationInput) Reset() { + *x = ConversationInput{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[102] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConversationInput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConversationInput) ProtoMessage() {} + +func (x *ConversationInput) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[102] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConversationInput.ProtoReflect.Descriptor instead. +func (*ConversationInput) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{102} +} + +func (x *ConversationInput) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *ConversationInput) GetRole() string { + if x != nil && x.Role != nil { + return *x.Role + } + return "" +} + +func (x *ConversationInput) GetScrubPII() bool { + if x != nil && x.ScrubPII != nil { + return *x.ScrubPII + } + return false +} + +// ConversationResult is the result for one input. +type ConversationResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Result for the one conversation input. + Result string `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"` + // Parameters for all custom fields. + Parameters map[string]*anypb.Any `protobuf:"bytes,2,rep,name=parameters,proto3" json:"parameters,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConversationResult) Reset() { + *x = ConversationResult{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[103] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConversationResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConversationResult) ProtoMessage() {} + +func (x *ConversationResult) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[103] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConversationResult.ProtoReflect.Descriptor instead. +func (*ConversationResult) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{103} +} + +func (x *ConversationResult) GetResult() string { + if x != nil { + return x.Result + } + return "" +} + +func (x *ConversationResult) GetParameters() map[string]*anypb.Any { + if x != nil { + return x.Parameters + } + return nil +} + +// ConversationResponse is the response for Conversation. +type ConversationResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The ID of an existing chat (like in ChatGPT) + ContextID *string `protobuf:"bytes,1,opt,name=contextID,proto3,oneof" json:"contextID,omitempty"` + // An array of results. + Outputs []*ConversationResult `protobuf:"bytes,2,rep,name=outputs,proto3" json:"outputs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ConversationResponse) Reset() { + *x = ConversationResponse{} + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[104] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ConversationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConversationResponse) ProtoMessage() {} + +func (x *ConversationResponse) ProtoReflect() protoreflect.Message { + mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[104] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ConversationResponse.ProtoReflect.Descriptor instead. +func (*ConversationResponse) Descriptor() ([]byte, []int) { + return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{104} +} + +func (x *ConversationResponse) GetContextID() string { + if x != nil && x.ContextID != nil { + return *x.ContextID + } + return "" +} + +func (x *ConversationResponse) GetOutputs() []*ConversationResult { + if x != nil { + return x.Outputs + } + return nil +} + +var File_dapr_proto_runtime_v1_dapr_proto protoreflect.FileDescriptor + +const file_dapr_proto_runtime_v1_dapr_proto_rawDesc = "" + + "\n" + + " dapr/proto/runtime/v1/dapr.proto\x12\x15dapr.proto.runtime.v1\x1a\x19google/protobuf/any.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a!dapr/proto/common/v1/common.proto\x1a'dapr/proto/runtime/v1/appcallback.proto\"e\n" + + "\x14InvokeServiceRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12=\n" + + "\amessage\x18\x03 \x01(\v2#.dapr.proto.common.v1.InvokeRequestR\amessage\"\xa8\x02\n" + + "\x0fGetStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\x12U\n" + + "\vconsistency\x18\x03 \x01(\x0e23.dapr.proto.common.v1.StateOptions.StateConsistencyR\vconsistency\x12P\n" + + "\bmetadata\x18\x04 \x03(\v24.dapr.proto.runtime.v1.GetStateRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xfd\x01\n" + + "\x13GetBulkStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x12\n" + + "\x04keys\x18\x02 \x03(\tR\x04keys\x12 \n" + + "\vparallelism\x18\x03 \x01(\x05R\vparallelism\x12T\n" + + "\bmetadata\x18\x04 \x03(\v28.dapr.proto.runtime.v1.GetBulkStateRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"R\n" + + "\x14GetBulkStateResponse\x12:\n" + + "\x05items\x18\x01 \x03(\v2$.dapr.proto.runtime.v1.BulkStateItemR\x05items\"\xec\x01\n" + + "\rBulkStateItem\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x12\n" + + "\x04data\x18\x02 \x01(\fR\x04data\x12\x12\n" + + "\x04etag\x18\x03 \x01(\tR\x04etag\x12\x14\n" + + "\x05error\x18\x04 \x01(\tR\x05error\x12N\n" + + "\bmetadata\x18\x05 \x03(\v22.dapr.proto.runtime.v1.BulkStateItem.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xca\x01\n" + + "\x10GetStateResponse\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\x12\x12\n" + + "\x04etag\x18\x02 \x01(\tR\x04etag\x12Q\n" + + "\bmetadata\x18\x03 \x03(\v25.dapr.proto.runtime.v1.GetStateResponse.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc5\x02\n" + + "\x12DeleteStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\x12.\n" + + "\x04etag\x18\x03 \x01(\v2\x1a.dapr.proto.common.v1.EtagR\x04etag\x12<\n" + + "\aoptions\x18\x04 \x01(\v2\".dapr.proto.common.v1.StateOptionsR\aoptions\x12S\n" + + "\bmetadata\x18\x05 \x03(\v27.dapr.proto.runtime.v1.DeleteStateRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"p\n" + + "\x16DeleteBulkStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x127\n" + + "\x06states\x18\x02 \x03(\v2\x1f.dapr.proto.common.v1.StateItemR\x06states\"j\n" + + "\x10SaveStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x127\n" + + "\x06states\x18\x02 \x03(\v2\x1f.dapr.proto.common.v1.StateItemR\x06states\"\xd9\x01\n" + + "\x11QueryStateRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x14\n" + + "\x05query\x18\x02 \x01(\tR\x05query\x12R\n" + + "\bmetadata\x18\x03 \x03(\v26.dapr.proto.runtime.v1.QueryStateRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"`\n" + + "\x0eQueryStateItem\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x12\n" + + "\x04data\x18\x02 \x01(\fR\x04data\x12\x12\n" + + "\x04etag\x18\x03 \x01(\tR\x04etag\x12\x14\n" + + "\x05error\x18\x04 \x01(\tR\x05error\"\xfd\x01\n" + + "\x12QueryStateResponse\x12?\n" + + "\aresults\x18\x01 \x03(\v2%.dapr.proto.runtime.v1.QueryStateItemR\aresults\x12\x14\n" + + "\x05token\x18\x02 \x01(\tR\x05token\x12S\n" + + "\bmetadata\x18\x03 \x03(\v27.dapr.proto.runtime.v1.QueryStateResponse.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x9f\x02\n" + + "\x13PublishEventRequest\x12\x1f\n" + + "\vpubsub_name\x18\x01 \x01(\tR\n" + + "pubsubName\x12\x14\n" + + "\x05topic\x18\x02 \x01(\tR\x05topic\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12*\n" + + "\x11data_content_type\x18\x04 \x01(\tR\x0fdataContentType\x12T\n" + + "\bmetadata\x18\x05 \x03(\v28.dapr.proto.runtime.v1.PublishEventRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xa7\x02\n" + + "\x12BulkPublishRequest\x12\x1f\n" + + "\vpubsub_name\x18\x01 \x01(\tR\n" + + "pubsubName\x12\x14\n" + + "\x05topic\x18\x02 \x01(\tR\x05topic\x12H\n" + + "\aentries\x18\x03 \x03(\v2..dapr.proto.runtime.v1.BulkPublishRequestEntryR\aentries\x12S\n" + + "\bmetadata\x18\x04 \x03(\v27.dapr.proto.runtime.v1.BulkPublishRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x84\x02\n" + + "\x17BulkPublishRequestEntry\x12\x19\n" + + "\bentry_id\x18\x01 \x01(\tR\aentryId\x12\x14\n" + + "\x05event\x18\x02 \x01(\fR\x05event\x12!\n" + + "\fcontent_type\x18\x03 \x01(\tR\vcontentType\x12X\n" + + "\bmetadata\x18\x04 \x03(\v2<.dapr.proto.runtime.v1.BulkPublishRequestEntry.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"r\n" + + "\x13BulkPublishResponse\x12[\n" + + "\rfailedEntries\x18\x01 \x03(\v25.dapr.proto.runtime.v1.BulkPublishResponseFailedEntryR\rfailedEntries\"Q\n" + + "\x1eBulkPublishResponseFailedEntry\x12\x19\n" + + "\bentry_id\x18\x01 \x01(\tR\aentryId\x12\x14\n" + + "\x05error\x18\x02 \x01(\tR\x05error\"\xa4\x02\n" + + "!SubscribeTopicEventsRequestAlpha1\x12j\n" + + "\x0finitial_request\x18\x01 \x01(\v2?.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1H\x00R\x0einitialRequest\x12l\n" + + "\x0fevent_processed\x18\x02 \x01(\v2A.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1H\x00R\x0eeventProcessedB%\n" + + "#subscribe_topic_events_request_type\"\xd0\x02\n" + + "(SubscribeTopicEventsRequestInitialAlpha1\x12\x1f\n" + + "\vpubsub_name\x18\x01 \x01(\tR\n" + + "pubsubName\x12\x14\n" + + "\x05topic\x18\x02 \x01(\tR\x05topic\x12i\n" + + "\bmetadata\x18\x03 \x03(\v2M.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.MetadataEntryR\bmetadata\x12/\n" + + "\x11dead_letter_topic\x18\x04 \x01(\tH\x00R\x0fdeadLetterTopic\x88\x01\x01\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x14\n" + + "\x12_dead_letter_topic\"\x7f\n" + + "*SubscribeTopicEventsRequestProcessedAlpha1\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12A\n" + + "\x06status\x18\x02 \x01(\v2).dapr.proto.runtime.v1.TopicEventResponseR\x06status\"\x8c\x02\n" + + "\"SubscribeTopicEventsResponseAlpha1\x12m\n" + + "\x10initial_response\x18\x01 \x01(\v2@.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1H\x00R\x0finitialResponse\x12O\n" + + "\revent_message\x18\x02 \x01(\v2(.dapr.proto.runtime.v1.TopicEventRequestH\x00R\feventMessageB&\n" + + "$subscribe_topic_events_response_type\"+\n" + + ")SubscribeTopicEventsResponseInitialAlpha1\"\xf0\x01\n" + + "\x14InvokeBindingRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" + + "\x04data\x18\x02 \x01(\fR\x04data\x12U\n" + + "\bmetadata\x18\x03 \x03(\v29.dapr.proto.runtime.v1.InvokeBindingRequest.MetadataEntryR\bmetadata\x12\x1c\n" + + "\toperation\x18\x04 \x01(\tR\toperation\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc0\x01\n" + + "\x15InvokeBindingResponse\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\x12V\n" + + "\bmetadata\x18\x02 \x03(\v2:.dapr.proto.runtime.v1.InvokeBindingResponse.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xd3\x01\n" + + "\x10GetSecretRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\x12Q\n" + + "\bmetadata\x18\x03 \x03(\v25.dapr.proto.runtime.v1.GetSecretRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x94\x01\n" + + "\x11GetSecretResponse\x12F\n" + + "\x04data\x18\x01 \x03(\v22.dapr.proto.runtime.v1.GetSecretResponse.DataEntryR\x04data\x1a7\n" + + "\tDataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc9\x01\n" + + "\x14GetBulkSecretRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12U\n" + + "\bmetadata\x18\x02 \x03(\v29.dapr.proto.runtime.v1.GetBulkSecretRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x9a\x01\n" + + "\x0eSecretResponse\x12L\n" + + "\asecrets\x18\x01 \x03(\v22.dapr.proto.runtime.v1.SecretResponse.SecretsEntryR\asecrets\x1a:\n" + + "\fSecretsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc3\x01\n" + + "\x15GetBulkSecretResponse\x12J\n" + + "\x04data\x18\x01 \x03(\v26.dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntryR\x04data\x1a^\n" + + "\tDataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12;\n" + + "\x05value\x18\x02 \x01(\v2%.dapr.proto.runtime.v1.SecretResponseR\x05value:\x028\x01\"~\n" + + "\x1bTransactionalStateOperation\x12$\n" + + "\roperationType\x18\x01 \x01(\tR\roperationType\x129\n" + + "\arequest\x18\x02 \x01(\v2\x1f.dapr.proto.common.v1.StateItemR\arequest\"\xb0\x02\n" + + "\x1eExecuteStateTransactionRequest\x12\x1c\n" + + "\tstoreName\x18\x01 \x01(\tR\tstoreName\x12R\n" + + "\n" + + "operations\x18\x02 \x03(\v22.dapr.proto.runtime.v1.TransactionalStateOperationR\n" + + "operations\x12_\n" + + "\bmetadata\x18\x03 \x03(\v2C.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xde\x01\n" + + "\x19RegisterActorTimerRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\x12\x19\n" + + "\bdue_time\x18\x04 \x01(\tR\adueTime\x12\x16\n" + + "\x06period\x18\x05 \x01(\tR\x06period\x12\x1a\n" + + "\bcallback\x18\x06 \x01(\tR\bcallback\x12\x12\n" + + "\x04data\x18\a \x01(\fR\x04data\x12\x10\n" + + "\x03ttl\x18\b \x01(\tR\x03ttl\"k\n" + + "\x1bUnregisterActorTimerRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\"\xc5\x01\n" + + "\x1cRegisterActorReminderRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\x12\x19\n" + + "\bdue_time\x18\x04 \x01(\tR\adueTime\x12\x16\n" + + "\x06period\x18\x05 \x01(\tR\x06period\x12\x12\n" + + "\x04data\x18\x06 \x01(\fR\x04data\x12\x10\n" + + "\x03ttl\x18\a \x01(\tR\x03ttl\"n\n" + + "\x1eUnregisterActorReminderRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\"b\n" + + "\x14GetActorStateRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x10\n" + + "\x03key\x18\x03 \x01(\tR\x03key\"\xc0\x01\n" + + "\x15GetActorStateResponse\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\x12V\n" + + "\bmetadata\x18\x02 \x03(\v2:.dapr.proto.runtime.v1.GetActorStateResponse.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xb8\x01\n" + + "#ExecuteActorStateTransactionRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12W\n" + + "\n" + + "operations\x18\x03 \x03(\v27.dapr.proto.runtime.v1.TransactionalActorStateOperationR\n" + + "operations\"\xa6\x02\n" + + " TransactionalActorStateOperation\x12$\n" + + "\roperationType\x18\x01 \x01(\tR\roperationType\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\x12*\n" + + "\x05value\x18\x03 \x01(\v2\x14.google.protobuf.AnyR\x05value\x12a\n" + + "\bmetadata\x18\x04 \x03(\v2E.dapr.proto.runtime.v1.TransactionalActorStateOperation.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x8c\x02\n" + + "\x12InvokeActorRequest\x12\x1d\n" + + "\n" + + "actor_type\x18\x01 \x01(\tR\tactorType\x12\x19\n" + + "\bactor_id\x18\x02 \x01(\tR\aactorId\x12\x16\n" + + "\x06method\x18\x03 \x01(\tR\x06method\x12\x12\n" + + "\x04data\x18\x04 \x01(\fR\x04data\x12S\n" + + "\bmetadata\x18\x05 \x03(\v27.dapr.proto.runtime.v1.InvokeActorRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\")\n" + + "\x13InvokeActorResponse\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\"\x14\n" + + "\x12GetMetadataRequest\"\x86\a\n" + + "\x13GetMetadataResponse\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12Q\n" + + "\x13active_actors_count\x18\x02 \x03(\v2(.dapr.proto.runtime.v1.ActiveActorsCountB\x02\x18\x01R\x06actors\x12V\n" + + "\x15registered_components\x18\x03 \x03(\v2+.dapr.proto.runtime.v1.RegisteredComponentsR\n" + + "components\x12e\n" + + "\x11extended_metadata\x18\x04 \x03(\v2@.dapr.proto.runtime.v1.GetMetadataResponse.ExtendedMetadataEntryR\bextended\x12O\n" + + "\rsubscriptions\x18\x05 \x03(\v2).dapr.proto.runtime.v1.PubsubSubscriptionR\rsubscriptions\x12R\n" + + "\x0ehttp_endpoints\x18\x06 \x03(\v2+.dapr.proto.runtime.v1.MetadataHTTPEndpointR\rhttpEndpoints\x12j\n" + + "\x19app_connection_properties\x18\a \x01(\v2..dapr.proto.runtime.v1.AppConnectionPropertiesR\x17appConnectionProperties\x12'\n" + + "\x0fruntime_version\x18\b \x01(\tR\x0eruntimeVersion\x12)\n" + + "\x10enabled_features\x18\t \x03(\tR\x0fenabledFeatures\x12H\n" + + "\ractor_runtime\x18\n" + + " \x01(\v2#.dapr.proto.runtime.v1.ActorRuntimeR\factorRuntime\x12K\n" + + "\tscheduler\x18\v \x01(\v2(.dapr.proto.runtime.v1.MetadataSchedulerH\x00R\tscheduler\x88\x01\x01\x1aC\n" + + "\x15ExtendedMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\f\n" + + "\n" + + "_scheduler\"D\n" + + "\x11MetadataScheduler\x12/\n" + + "\x13connected_addresses\x18\x01 \x03(\tR\x12connectedAddresses\"\xbc\x02\n" + + "\fActorRuntime\x12]\n" + + "\x0eruntime_status\x18\x01 \x01(\x0e26.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatusR\rruntimeStatus\x12M\n" + + "\ractive_actors\x18\x02 \x03(\v2(.dapr.proto.runtime.v1.ActiveActorsCountR\factiveActors\x12\x1d\n" + + "\n" + + "host_ready\x18\x03 \x01(\bR\thostReady\x12\x1c\n" + + "\tplacement\x18\x04 \x01(\tR\tplacement\"A\n" + + "\x12ActorRuntimeStatus\x12\x10\n" + + "\fINITIALIZING\x10\x00\x12\f\n" + + "\bDISABLED\x10\x01\x12\v\n" + + "\aRUNNING\x10\x02\"=\n" + + "\x11ActiveActorsCount\x12\x12\n" + + "\x04type\x18\x01 \x01(\tR\x04type\x12\x14\n" + + "\x05count\x18\x02 \x01(\x05R\x05count\"|\n" + + "\x14RegisteredComponents\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" + + "\x04type\x18\x02 \x01(\tR\x04type\x12\x18\n" + + "\aversion\x18\x03 \x01(\tR\aversion\x12\"\n" + + "\fcapabilities\x18\x04 \x03(\tR\fcapabilities\"*\n" + + "\x14MetadataHTTPEndpoint\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\"\xe9\x01\n" + + "\x17AppConnectionProperties\x12\x12\n" + + "\x04port\x18\x01 \x01(\x05R\x04port\x12\x1a\n" + + "\bprotocol\x18\x02 \x01(\tR\bprotocol\x12'\n" + + "\x0fchannel_address\x18\x03 \x01(\tR\x0echannelAddress\x12'\n" + + "\x0fmax_concurrency\x18\x04 \x01(\x05R\x0emaxConcurrency\x12L\n" + + "\x06health\x18\x05 \x01(\v24.dapr.proto.runtime.v1.AppConnectionHealthPropertiesR\x06health\"\xdc\x01\n" + + "\x1dAppConnectionHealthProperties\x12*\n" + + "\x11health_check_path\x18\x01 \x01(\tR\x0fhealthCheckPath\x122\n" + + "\x15health_probe_interval\x18\x02 \x01(\tR\x13healthProbeInterval\x120\n" + + "\x14health_probe_timeout\x18\x03 \x01(\tR\x12healthProbeTimeout\x12)\n" + + "\x10health_threshold\x18\x04 \x01(\x05R\x0fhealthThreshold\"\x92\x03\n" + + "\x12PubsubSubscription\x12\x1f\n" + + "\vpubsub_name\x18\x01 \x01(\tR\n" + + "pubsubname\x12\x14\n" + + "\x05topic\x18\x02 \x01(\tR\x05topic\x12S\n" + + "\bmetadata\x18\x03 \x03(\v27.dapr.proto.runtime.v1.PubsubSubscription.MetadataEntryR\bmetadata\x12D\n" + + "\x05rules\x18\x04 \x01(\v2..dapr.proto.runtime.v1.PubsubSubscriptionRulesR\x05rules\x12*\n" + + "\x11dead_letter_topic\x18\x05 \x01(\tR\x0fdeadLetterTopic\x12A\n" + + "\x04type\x18\x06 \x01(\x0e2-.dapr.proto.runtime.v1.PubsubSubscriptionTypeR\x04type\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"^\n" + + "\x17PubsubSubscriptionRules\x12C\n" + + "\x05rules\x18\x01 \x03(\v2-.dapr.proto.runtime.v1.PubsubSubscriptionRuleR\x05rules\"B\n" + + "\x16PubsubSubscriptionRule\x12\x14\n" + + "\x05match\x18\x01 \x01(\tR\x05match\x12\x12\n" + + "\x04path\x18\x02 \x01(\tR\x04path\"<\n" + + "\x12SetMetadataRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value\"\xe3\x01\n" + + "\x17GetConfigurationRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x12\n" + + "\x04keys\x18\x02 \x03(\tR\x04keys\x12X\n" + + "\bmetadata\x18\x03 \x03(\v2<.dapr.proto.runtime.v1.GetConfigurationRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xcf\x01\n" + + "\x18GetConfigurationResponse\x12P\n" + + "\x05items\x18\x01 \x03(\v2:.dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntryR\x05items\x1aa\n" + + "\n" + + "ItemsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12=\n" + + "\x05value\x18\x02 \x01(\v2'.dapr.proto.common.v1.ConfigurationItemR\x05value:\x028\x01\"\xef\x01\n" + + "\x1dSubscribeConfigurationRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x12\n" + + "\x04keys\x18\x02 \x03(\tR\x04keys\x12^\n" + + "\bmetadata\x18\x03 \x03(\v2B.dapr.proto.runtime.v1.SubscribeConfigurationRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"P\n" + + "\x1fUnsubscribeConfigurationRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x0e\n" + + "\x02id\x18\x02 \x01(\tR\x02id\"\xeb\x01\n" + + "\x1eSubscribeConfigurationResponse\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12V\n" + + "\x05items\x18\x02 \x03(\v2@.dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntryR\x05items\x1aa\n" + + "\n" + + "ItemsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12=\n" + + "\x05value\x18\x02 \x01(\v2'.dapr.proto.common.v1.ConfigurationItemR\x05value:\x028\x01\"L\n" + + " UnsubscribeConfigurationResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\"\x9b\x01\n" + + "\x0eTryLockRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x1f\n" + + "\vresource_id\x18\x02 \x01(\tR\n" + + "resourceId\x12\x1d\n" + + "\n" + + "lock_owner\x18\x03 \x01(\tR\tlockOwner\x12*\n" + + "\x11expiry_in_seconds\x18\x04 \x01(\x05R\x0fexpiryInSeconds\"+\n" + + "\x0fTryLockResponse\x12\x18\n" + + "\asuccess\x18\x01 \x01(\bR\asuccess\"n\n" + + "\rUnlockRequest\x12\x1d\n" + + "\n" + + "store_name\x18\x01 \x01(\tR\tstoreName\x12\x1f\n" + + "\vresource_id\x18\x02 \x01(\tR\n" + + "resourceId\x12\x1d\n" + + "\n" + + "lock_owner\x18\x03 \x01(\tR\tlockOwner\"\xb6\x01\n" + + "\x0eUnlockResponse\x12D\n" + + "\x06status\x18\x01 \x01(\x0e2,.dapr.proto.runtime.v1.UnlockResponse.StatusR\x06status\"^\n" + + "\x06Status\x12\v\n" + + "\aSUCCESS\x10\x00\x12\x17\n" + + "\x13LOCK_DOES_NOT_EXIST\x10\x01\x12\x1a\n" + + "\x16LOCK_BELONGS_TO_OTHERS\x10\x02\x12\x12\n" + + "\x0eINTERNAL_ERROR\x10\x03\"\xbe\x01\n" + + "\x13SubtleGetKeyRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12L\n" + + "\x06format\x18\x03 \x01(\x0e24.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormatR\x06format\"\x1e\n" + + "\tKeyFormat\x12\a\n" + + "\x03PEM\x10\x00\x12\b\n" + + "\x04JSON\x10\x01\"I\n" + + "\x14SubtleGetKeyResponse\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1d\n" + + "\n" + + "public_key\x18\x02 \x01(\tR\tpublicKey\"\xd3\x01\n" + + "\x14SubtleEncryptRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x1c\n" + + "\tplaintext\x18\x02 \x01(\fR\tplaintext\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\x12\x14\n" + + "\x05nonce\x18\x05 \x01(\fR\x05nonce\x12'\n" + + "\x0fassociated_data\x18\x06 \x01(\fR\x0eassociatedData\"I\n" + + "\x15SubtleEncryptResponse\x12\x1e\n" + + "\n" + + "ciphertext\x18\x01 \x01(\fR\n" + + "ciphertext\x12\x10\n" + + "\x03tag\x18\x02 \x01(\fR\x03tag\"\xe7\x01\n" + + "\x14SubtleDecryptRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x1e\n" + + "\n" + + "ciphertext\x18\x02 \x01(\fR\n" + + "ciphertext\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\x12\x14\n" + + "\x05nonce\x18\x05 \x01(\fR\x05nonce\x12\x10\n" + + "\x03tag\x18\x06 \x01(\fR\x03tag\x12'\n" + + "\x0fassociated_data\x18\a \x01(\fR\x0eassociatedData\"5\n" + + "\x15SubtleDecryptResponse\x12\x1c\n" + + "\tplaintext\x18\x01 \x01(\fR\tplaintext\"\xda\x01\n" + + "\x14SubtleWrapKeyRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12#\n" + + "\rplaintext_key\x18\x02 \x01(\fR\fplaintextKey\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\x12\x14\n" + + "\x05nonce\x18\x05 \x01(\fR\x05nonce\x12'\n" + + "\x0fassociated_data\x18\x06 \x01(\fR\x0eassociatedData\"J\n" + + "\x15SubtleWrapKeyResponse\x12\x1f\n" + + "\vwrapped_key\x18\x01 \x01(\fR\n" + + "wrappedKey\x12\x10\n" + + "\x03tag\x18\x02 \x01(\fR\x03tag\"\xea\x01\n" + + "\x16SubtleUnwrapKeyRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x1f\n" + + "\vwrapped_key\x18\x02 \x01(\fR\n" + + "wrappedKey\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\x12\x14\n" + + "\x05nonce\x18\x05 \x01(\fR\x05nonce\x12\x10\n" + + "\x03tag\x18\x06 \x01(\fR\x03tag\x12'\n" + + "\x0fassociated_data\x18\a \x01(\fR\x0eassociatedData\">\n" + + "\x17SubtleUnwrapKeyResponse\x12#\n" + + "\rplaintext_key\x18\x01 \x01(\fR\fplaintextKey\"\x8b\x01\n" + + "\x11SubtleSignRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x16\n" + + "\x06digest\x18\x02 \x01(\fR\x06digest\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\"2\n" + + "\x12SubtleSignResponse\x12\x1c\n" + + "\tsignature\x18\x01 \x01(\fR\tsignature\"\xab\x01\n" + + "\x13SubtleVerifyRequest\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x16\n" + + "\x06digest\x18\x02 \x01(\fR\x06digest\x12\x1c\n" + + "\talgorithm\x18\x03 \x01(\tR\talgorithm\x12\x19\n" + + "\bkey_name\x18\x04 \x01(\tR\akeyName\x12\x1c\n" + + "\tsignature\x18\x05 \x01(\fR\tsignature\",\n" + + "\x14SubtleVerifyResponse\x12\x14\n" + + "\x05valid\x18\x01 \x01(\bR\x05valid\"\x97\x01\n" + + "\x0eEncryptRequest\x12F\n" + + "\aoptions\x18\x01 \x01(\v2,.dapr.proto.runtime.v1.EncryptRequestOptionsR\aoptions\x12=\n" + + "\apayload\x18\x02 \x01(\v2#.dapr.proto.common.v1.StreamPayloadR\apayload\"\xa6\x02\n" + + "\x15EncryptRequestOptions\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x19\n" + + "\bkey_name\x18\x02 \x01(\tR\akeyName\x12,\n" + + "\x12key_wrap_algorithm\x18\x03 \x01(\tR\x10keyWrapAlgorithm\x124\n" + + "\x16data_encryption_cipher\x18\n" + + " \x01(\tR\x14dataEncryptionCipher\x127\n" + + "\x18omit_decryption_key_name\x18\v \x01(\bR\x15omitDecryptionKeyName\x12.\n" + + "\x13decryption_key_name\x18\f \x01(\tR\x11decryptionKeyName\"P\n" + + "\x0fEncryptResponse\x12=\n" + + "\apayload\x18\x01 \x01(\v2#.dapr.proto.common.v1.StreamPayloadR\apayload\"\x97\x01\n" + + "\x0eDecryptRequest\x12F\n" + + "\aoptions\x18\x01 \x01(\v2,.dapr.proto.runtime.v1.DecryptRequestOptionsR\aoptions\x12=\n" + + "\apayload\x18\x02 \x01(\v2#.dapr.proto.common.v1.StreamPayloadR\apayload\"Y\n" + + "\x15DecryptRequestOptions\x12%\n" + + "\x0ecomponent_name\x18\x01 \x01(\tR\rcomponentName\x12\x19\n" + + "\bkey_name\x18\f \x01(\tR\akeyName\"P\n" + + "\x0fDecryptResponse\x12=\n" + + "\apayload\x18\x01 \x01(\v2#.dapr.proto.common.v1.StreamPayloadR\apayload\"d\n" + + "\x12GetWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\"\x9c\x03\n" + + "\x13GetWorkflowResponse\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12#\n" + + "\rworkflow_name\x18\x02 \x01(\tR\fworkflowName\x129\n" + + "\n" + + "created_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x12B\n" + + "\x0flast_updated_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\rlastUpdatedAt\x12%\n" + + "\x0eruntime_status\x18\x05 \x01(\tR\rruntimeStatus\x12Z\n" + + "\n" + + "properties\x18\x06 \x03(\v2:.dapr.proto.runtime.v1.GetWorkflowResponse.PropertiesEntryR\n" + + "properties\x1a=\n" + + "\x0fPropertiesEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xb1\x02\n" + + "\x14StartWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\x12#\n" + + "\rworkflow_name\x18\x03 \x01(\tR\fworkflowName\x12R\n" + + "\aoptions\x18\x04 \x03(\v28.dapr.proto.runtime.v1.StartWorkflowRequest.OptionsEntryR\aoptions\x12\x14\n" + + "\x05input\x18\x05 \x01(\fR\x05input\x1a:\n" + + "\fOptionsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"8\n" + + "\x15StartWorkflowResponse\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\"j\n" + + "\x18TerminateWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\"f\n" + + "\x14PauseWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\"g\n" + + "\x15ResumeWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\"\xa9\x01\n" + + "\x19RaiseEventWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\x12\x1d\n" + + "\n" + + "event_name\x18\x03 \x01(\tR\teventName\x12\x1d\n" + + "\n" + + "event_data\x18\x04 \x01(\fR\teventData\"f\n" + + "\x14PurgeWorkflowRequest\x12\x1f\n" + + "\vinstance_id\x18\x01 \x01(\tR\n" + + "instanceID\x12-\n" + + "\x12workflow_component\x18\x02 \x01(\tR\x11workflowComponent\"\x11\n" + + "\x0fShutdownRequest\"\xed\x02\n" + + "\x03Job\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1f\n" + + "\bschedule\x18\x02 \x01(\tH\x00R\bschedule\x88\x01\x01\x12\x1d\n" + + "\arepeats\x18\x03 \x01(\rH\x01R\arepeats\x88\x01\x01\x12\x1e\n" + + "\bdue_time\x18\x04 \x01(\tH\x02R\adueTime\x88\x01\x01\x12\x15\n" + + "\x03ttl\x18\x05 \x01(\tH\x03R\x03ttl\x88\x01\x01\x12(\n" + + "\x04data\x18\x06 \x01(\v2\x14.google.protobuf.AnyR\x04data\x12\x1c\n" + + "\toverwrite\x18\a \x01(\bR\toverwrite\x12R\n" + + "\x0efailure_policy\x18\b \x01(\v2&.dapr.proto.common.v1.JobFailurePolicyH\x04R\rfailurePolicy\x88\x01\x01B\v\n" + + "\t_scheduleB\n" + + "\n" + + "\b_repeatsB\v\n" + + "\t_due_timeB\x06\n" + + "\x04_ttlB\x11\n" + + "\x0f_failure_policy\"B\n" + + "\x12ScheduleJobRequest\x12,\n" + + "\x03job\x18\x01 \x01(\v2\x1a.dapr.proto.runtime.v1.JobR\x03job\"\x15\n" + + "\x13ScheduleJobResponse\"#\n" + + "\rGetJobRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\">\n" + + "\x0eGetJobResponse\x12,\n" + + "\x03job\x18\x01 \x01(\v2\x1a.dapr.proto.runtime.v1.JobR\x03job\"&\n" + + "\x10DeleteJobRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\"\x13\n" + + "\x11DeleteJobResponse\"\xc5\x04\n" + + "\x13ConversationRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12!\n" + + "\tcontextID\x18\x02 \x01(\tH\x00R\tcontextID\x88\x01\x01\x12@\n" + + "\x06inputs\x18\x03 \x03(\v2(.dapr.proto.runtime.v1.ConversationInputR\x06inputs\x12Z\n" + + "\n" + + "parameters\x18\x04 \x03(\v2:.dapr.proto.runtime.v1.ConversationRequest.ParametersEntryR\n" + + "parameters\x12T\n" + + "\bmetadata\x18\x05 \x03(\v28.dapr.proto.runtime.v1.ConversationRequest.MetadataEntryR\bmetadata\x12\x1f\n" + + "\bscrubPII\x18\x06 \x01(\bH\x01R\bscrubPII\x88\x01\x01\x12%\n" + + "\vtemperature\x18\a \x01(\x01H\x02R\vtemperature\x88\x01\x01\x1aS\n" + + "\x0fParametersEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12*\n" + + "\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\f\n" + + "\n" + + "_contextIDB\v\n" + + "\t_scrubPIIB\x0e\n" + + "\f_temperature\"}\n" + + "\x11ConversationInput\x12\x18\n" + + "\acontent\x18\x01 \x01(\tR\acontent\x12\x17\n" + + "\x04role\x18\x02 \x01(\tH\x00R\x04role\x88\x01\x01\x12\x1f\n" + + "\bscrubPII\x18\x03 \x01(\bH\x01R\bscrubPII\x88\x01\x01B\a\n" + + "\x05_roleB\v\n" + + "\t_scrubPII\"\xdc\x01\n" + + "\x12ConversationResult\x12\x16\n" + + "\x06result\x18\x01 \x01(\tR\x06result\x12Y\n" + + "\n" + + "parameters\x18\x02 \x03(\v29.dapr.proto.runtime.v1.ConversationResult.ParametersEntryR\n" + + "parameters\x1aS\n" + + "\x0fParametersEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12*\n" + + "\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\"\x8c\x01\n" + + "\x14ConversationResponse\x12!\n" + + "\tcontextID\x18\x01 \x01(\tH\x00R\tcontextID\x88\x01\x01\x12C\n" + + "\aoutputs\x18\x02 \x03(\v2).dapr.proto.runtime.v1.ConversationResultR\aoutputsB\f\n" + + "\n" + + "_contextID*W\n" + + "\x16PubsubSubscriptionType\x12\v\n" + + "\aUNKNOWN\x10\x00\x12\x0f\n" + + "\vDECLARATIVE\x10\x01\x12\x10\n" + + "\fPROGRAMMATIC\x10\x02\x12\r\n" + + "\tSTREAMING\x10\x032\xbe1\n" + + "\x04Dapr\x12d\n" + + "\rInvokeService\x12+.dapr.proto.runtime.v1.InvokeServiceRequest\x1a$.dapr.proto.common.v1.InvokeResponse\"\x00\x12]\n" + + "\bGetState\x12&.dapr.proto.runtime.v1.GetStateRequest\x1a'.dapr.proto.runtime.v1.GetStateResponse\"\x00\x12i\n" + + "\fGetBulkState\x12*.dapr.proto.runtime.v1.GetBulkStateRequest\x1a+.dapr.proto.runtime.v1.GetBulkStateResponse\"\x00\x12N\n" + + "\tSaveState\x12'.dapr.proto.runtime.v1.SaveStateRequest\x1a\x16.google.protobuf.Empty\"\x00\x12i\n" + + "\x10QueryStateAlpha1\x12(.dapr.proto.runtime.v1.QueryStateRequest\x1a).dapr.proto.runtime.v1.QueryStateResponse\"\x00\x12R\n" + + "\vDeleteState\x12).dapr.proto.runtime.v1.DeleteStateRequest\x1a\x16.google.protobuf.Empty\"\x00\x12Z\n" + + "\x0fDeleteBulkState\x12-.dapr.proto.runtime.v1.DeleteBulkStateRequest\x1a\x16.google.protobuf.Empty\"\x00\x12j\n" + + "\x17ExecuteStateTransaction\x125.dapr.proto.runtime.v1.ExecuteStateTransactionRequest\x1a\x16.google.protobuf.Empty\"\x00\x12T\n" + + "\fPublishEvent\x12*.dapr.proto.runtime.v1.PublishEventRequest\x1a\x16.google.protobuf.Empty\"\x00\x12q\n" + + "\x16BulkPublishEventAlpha1\x12).dapr.proto.runtime.v1.BulkPublishRequest\x1a*.dapr.proto.runtime.v1.BulkPublishResponse\"\x00\x12\x97\x01\n" + + "\x1aSubscribeTopicEventsAlpha1\x128.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1\x1a9.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1\"\x00(\x010\x01\x12l\n" + + "\rInvokeBinding\x12+.dapr.proto.runtime.v1.InvokeBindingRequest\x1a,.dapr.proto.runtime.v1.InvokeBindingResponse\"\x00\x12`\n" + + "\tGetSecret\x12'.dapr.proto.runtime.v1.GetSecretRequest\x1a(.dapr.proto.runtime.v1.GetSecretResponse\"\x00\x12l\n" + + "\rGetBulkSecret\x12+.dapr.proto.runtime.v1.GetBulkSecretRequest\x1a,.dapr.proto.runtime.v1.GetBulkSecretResponse\"\x00\x12`\n" + + "\x12RegisterActorTimer\x120.dapr.proto.runtime.v1.RegisterActorTimerRequest\x1a\x16.google.protobuf.Empty\"\x00\x12d\n" + + "\x14UnregisterActorTimer\x122.dapr.proto.runtime.v1.UnregisterActorTimerRequest\x1a\x16.google.protobuf.Empty\"\x00\x12f\n" + + "\x15RegisterActorReminder\x123.dapr.proto.runtime.v1.RegisterActorReminderRequest\x1a\x16.google.protobuf.Empty\"\x00\x12j\n" + + "\x17UnregisterActorReminder\x125.dapr.proto.runtime.v1.UnregisterActorReminderRequest\x1a\x16.google.protobuf.Empty\"\x00\x12l\n" + + "\rGetActorState\x12+.dapr.proto.runtime.v1.GetActorStateRequest\x1a,.dapr.proto.runtime.v1.GetActorStateResponse\"\x00\x12t\n" + + "\x1cExecuteActorStateTransaction\x12:.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest\x1a\x16.google.protobuf.Empty\"\x00\x12f\n" + + "\vInvokeActor\x12).dapr.proto.runtime.v1.InvokeActorRequest\x1a*.dapr.proto.runtime.v1.InvokeActorResponse\"\x00\x12{\n" + + "\x16GetConfigurationAlpha1\x12..dapr.proto.runtime.v1.GetConfigurationRequest\x1a/.dapr.proto.runtime.v1.GetConfigurationResponse\"\x00\x12u\n" + + "\x10GetConfiguration\x12..dapr.proto.runtime.v1.GetConfigurationRequest\x1a/.dapr.proto.runtime.v1.GetConfigurationResponse\"\x00\x12\x8f\x01\n" + + "\x1cSubscribeConfigurationAlpha1\x124.dapr.proto.runtime.v1.SubscribeConfigurationRequest\x1a5.dapr.proto.runtime.v1.SubscribeConfigurationResponse\"\x000\x01\x12\x89\x01\n" + + "\x16SubscribeConfiguration\x124.dapr.proto.runtime.v1.SubscribeConfigurationRequest\x1a5.dapr.proto.runtime.v1.SubscribeConfigurationResponse\"\x000\x01\x12\x93\x01\n" + + "\x1eUnsubscribeConfigurationAlpha1\x126.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest\x1a7.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse\"\x00\x12\x8d\x01\n" + + "\x18UnsubscribeConfiguration\x126.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest\x1a7.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse\"\x00\x12`\n" + + "\rTryLockAlpha1\x12%.dapr.proto.runtime.v1.TryLockRequest\x1a&.dapr.proto.runtime.v1.TryLockResponse\"\x00\x12]\n" + + "\fUnlockAlpha1\x12$.dapr.proto.runtime.v1.UnlockRequest\x1a%.dapr.proto.runtime.v1.UnlockResponse\"\x00\x12b\n" + + "\rEncryptAlpha1\x12%.dapr.proto.runtime.v1.EncryptRequest\x1a&.dapr.proto.runtime.v1.EncryptResponse(\x010\x01\x12b\n" + + "\rDecryptAlpha1\x12%.dapr.proto.runtime.v1.DecryptRequest\x1a&.dapr.proto.runtime.v1.DecryptResponse(\x010\x01\x12f\n" + + "\vGetMetadata\x12).dapr.proto.runtime.v1.GetMetadataRequest\x1a*.dapr.proto.runtime.v1.GetMetadataResponse\"\x00\x12R\n" + + "\vSetMetadata\x12).dapr.proto.runtime.v1.SetMetadataRequest\x1a\x16.google.protobuf.Empty\"\x00\x12m\n" + + "\x12SubtleGetKeyAlpha1\x12*.dapr.proto.runtime.v1.SubtleGetKeyRequest\x1a+.dapr.proto.runtime.v1.SubtleGetKeyResponse\x12p\n" + + "\x13SubtleEncryptAlpha1\x12+.dapr.proto.runtime.v1.SubtleEncryptRequest\x1a,.dapr.proto.runtime.v1.SubtleEncryptResponse\x12p\n" + + "\x13SubtleDecryptAlpha1\x12+.dapr.proto.runtime.v1.SubtleDecryptRequest\x1a,.dapr.proto.runtime.v1.SubtleDecryptResponse\x12p\n" + + "\x13SubtleWrapKeyAlpha1\x12+.dapr.proto.runtime.v1.SubtleWrapKeyRequest\x1a,.dapr.proto.runtime.v1.SubtleWrapKeyResponse\x12v\n" + + "\x15SubtleUnwrapKeyAlpha1\x12-.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest\x1a..dapr.proto.runtime.v1.SubtleUnwrapKeyResponse\x12g\n" + + "\x10SubtleSignAlpha1\x12(.dapr.proto.runtime.v1.SubtleSignRequest\x1a).dapr.proto.runtime.v1.SubtleSignResponse\x12m\n" + + "\x12SubtleVerifyAlpha1\x12*.dapr.proto.runtime.v1.SubtleVerifyRequest\x1a+.dapr.proto.runtime.v1.SubtleVerifyResponse\x12u\n" + + "\x13StartWorkflowAlpha1\x12+.dapr.proto.runtime.v1.StartWorkflowRequest\x1a,.dapr.proto.runtime.v1.StartWorkflowResponse\"\x03\x88\x02\x01\x12o\n" + + "\x11GetWorkflowAlpha1\x12).dapr.proto.runtime.v1.GetWorkflowRequest\x1a*.dapr.proto.runtime.v1.GetWorkflowResponse\"\x03\x88\x02\x01\x12_\n" + + "\x13PurgeWorkflowAlpha1\x12+.dapr.proto.runtime.v1.PurgeWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x03\x88\x02\x01\x12g\n" + + "\x17TerminateWorkflowAlpha1\x12/.dapr.proto.runtime.v1.TerminateWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x03\x88\x02\x01\x12_\n" + + "\x13PauseWorkflowAlpha1\x12+.dapr.proto.runtime.v1.PauseWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x03\x88\x02\x01\x12a\n" + + "\x14ResumeWorkflowAlpha1\x12,.dapr.proto.runtime.v1.ResumeWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x03\x88\x02\x01\x12i\n" + + "\x18RaiseEventWorkflowAlpha1\x120.dapr.proto.runtime.v1.RaiseEventWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x03\x88\x02\x01\x12q\n" + + "\x12StartWorkflowBeta1\x12+.dapr.proto.runtime.v1.StartWorkflowRequest\x1a,.dapr.proto.runtime.v1.StartWorkflowResponse\"\x00\x12k\n" + + "\x10GetWorkflowBeta1\x12).dapr.proto.runtime.v1.GetWorkflowRequest\x1a*.dapr.proto.runtime.v1.GetWorkflowResponse\"\x00\x12[\n" + + "\x12PurgeWorkflowBeta1\x12+.dapr.proto.runtime.v1.PurgeWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x00\x12c\n" + + "\x16TerminateWorkflowBeta1\x12/.dapr.proto.runtime.v1.TerminateWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x00\x12[\n" + + "\x12PauseWorkflowBeta1\x12+.dapr.proto.runtime.v1.PauseWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x00\x12]\n" + + "\x13ResumeWorkflowBeta1\x12,.dapr.proto.runtime.v1.ResumeWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x00\x12e\n" + + "\x17RaiseEventWorkflowBeta1\x120.dapr.proto.runtime.v1.RaiseEventWorkflowRequest\x1a\x16.google.protobuf.Empty\"\x00\x12L\n" + + "\bShutdown\x12&.dapr.proto.runtime.v1.ShutdownRequest\x1a\x16.google.protobuf.Empty\"\x00\x12l\n" + + "\x11ScheduleJobAlpha1\x12).dapr.proto.runtime.v1.ScheduleJobRequest\x1a*.dapr.proto.runtime.v1.ScheduleJobResponse\"\x00\x12]\n" + + "\fGetJobAlpha1\x12$.dapr.proto.runtime.v1.GetJobRequest\x1a%.dapr.proto.runtime.v1.GetJobResponse\"\x00\x12f\n" + + "\x0fDeleteJobAlpha1\x12'.dapr.proto.runtime.v1.DeleteJobRequest\x1a(.dapr.proto.runtime.v1.DeleteJobResponse\"\x00\x12k\n" + + "\x0eConverseAlpha1\x12*.dapr.proto.runtime.v1.ConversationRequest\x1a+.dapr.proto.runtime.v1.ConversationResponse\"\x00B\xe4\x01\n" + + "\x19com.dapr.proto.runtime.v1B\tDaprProtoP\x01ZEgithub.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1;runtimev1\xa2\x02\x03DPR\xaa\x02\x15Dapr.Proto.Runtime.V1\xca\x02\x15Dapr\\Proto\\Runtime\\V1\xe2\x02!Dapr\\Proto\\Runtime\\V1\\GPBMetadata\xea\x02\x18Dapr::Proto::Runtime::V1b\x06proto3" + +var ( + file_dapr_proto_runtime_v1_dapr_proto_rawDescOnce sync.Once + file_dapr_proto_runtime_v1_dapr_proto_rawDescData []byte +) + +func file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP() []byte { + file_dapr_proto_runtime_v1_dapr_proto_rawDescOnce.Do(func() { + file_dapr_proto_runtime_v1_dapr_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_dapr_proto_runtime_v1_dapr_proto_rawDesc), len(file_dapr_proto_runtime_v1_dapr_proto_rawDesc))) + }) + return file_dapr_proto_runtime_v1_dapr_proto_rawDescData +} + +var file_dapr_proto_runtime_v1_dapr_proto_enumTypes = make([]protoimpl.EnumInfo, 4) +var file_dapr_proto_runtime_v1_dapr_proto_msgTypes = make([]protoimpl.MessageInfo, 138) +var file_dapr_proto_runtime_v1_dapr_proto_goTypes = []any{ + (PubsubSubscriptionType)(0), // 0: dapr.proto.runtime.v1.PubsubSubscriptionType + (ActorRuntime_ActorRuntimeStatus)(0), // 1: dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus + (UnlockResponse_Status)(0), // 2: dapr.proto.runtime.v1.UnlockResponse.Status + (SubtleGetKeyRequest_KeyFormat)(0), // 3: dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat + (*InvokeServiceRequest)(nil), // 4: dapr.proto.runtime.v1.InvokeServiceRequest + (*GetStateRequest)(nil), // 5: dapr.proto.runtime.v1.GetStateRequest + (*GetBulkStateRequest)(nil), // 6: dapr.proto.runtime.v1.GetBulkStateRequest + (*GetBulkStateResponse)(nil), // 7: dapr.proto.runtime.v1.GetBulkStateResponse + (*BulkStateItem)(nil), // 8: dapr.proto.runtime.v1.BulkStateItem + (*GetStateResponse)(nil), // 9: dapr.proto.runtime.v1.GetStateResponse + (*DeleteStateRequest)(nil), // 10: dapr.proto.runtime.v1.DeleteStateRequest + (*DeleteBulkStateRequest)(nil), // 11: dapr.proto.runtime.v1.DeleteBulkStateRequest + (*SaveStateRequest)(nil), // 12: dapr.proto.runtime.v1.SaveStateRequest + (*QueryStateRequest)(nil), // 13: dapr.proto.runtime.v1.QueryStateRequest + (*QueryStateItem)(nil), // 14: dapr.proto.runtime.v1.QueryStateItem + (*QueryStateResponse)(nil), // 15: dapr.proto.runtime.v1.QueryStateResponse + (*PublishEventRequest)(nil), // 16: dapr.proto.runtime.v1.PublishEventRequest + (*BulkPublishRequest)(nil), // 17: dapr.proto.runtime.v1.BulkPublishRequest + (*BulkPublishRequestEntry)(nil), // 18: dapr.proto.runtime.v1.BulkPublishRequestEntry + (*BulkPublishResponse)(nil), // 19: dapr.proto.runtime.v1.BulkPublishResponse + (*BulkPublishResponseFailedEntry)(nil), // 20: dapr.proto.runtime.v1.BulkPublishResponseFailedEntry + (*SubscribeTopicEventsRequestAlpha1)(nil), // 21: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1 + (*SubscribeTopicEventsRequestInitialAlpha1)(nil), // 22: dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1 + (*SubscribeTopicEventsRequestProcessedAlpha1)(nil), // 23: dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1 + (*SubscribeTopicEventsResponseAlpha1)(nil), // 24: dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1 + (*SubscribeTopicEventsResponseInitialAlpha1)(nil), // 25: dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1 + (*InvokeBindingRequest)(nil), // 26: dapr.proto.runtime.v1.InvokeBindingRequest + (*InvokeBindingResponse)(nil), // 27: dapr.proto.runtime.v1.InvokeBindingResponse + (*GetSecretRequest)(nil), // 28: dapr.proto.runtime.v1.GetSecretRequest + (*GetSecretResponse)(nil), // 29: dapr.proto.runtime.v1.GetSecretResponse + (*GetBulkSecretRequest)(nil), // 30: dapr.proto.runtime.v1.GetBulkSecretRequest + (*SecretResponse)(nil), // 31: dapr.proto.runtime.v1.SecretResponse + (*GetBulkSecretResponse)(nil), // 32: dapr.proto.runtime.v1.GetBulkSecretResponse + (*TransactionalStateOperation)(nil), // 33: dapr.proto.runtime.v1.TransactionalStateOperation + (*ExecuteStateTransactionRequest)(nil), // 34: dapr.proto.runtime.v1.ExecuteStateTransactionRequest + (*RegisterActorTimerRequest)(nil), // 35: dapr.proto.runtime.v1.RegisterActorTimerRequest + (*UnregisterActorTimerRequest)(nil), // 36: dapr.proto.runtime.v1.UnregisterActorTimerRequest + (*RegisterActorReminderRequest)(nil), // 37: dapr.proto.runtime.v1.RegisterActorReminderRequest + (*UnregisterActorReminderRequest)(nil), // 38: dapr.proto.runtime.v1.UnregisterActorReminderRequest + (*GetActorStateRequest)(nil), // 39: dapr.proto.runtime.v1.GetActorStateRequest + (*GetActorStateResponse)(nil), // 40: dapr.proto.runtime.v1.GetActorStateResponse + (*ExecuteActorStateTransactionRequest)(nil), // 41: dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest + (*TransactionalActorStateOperation)(nil), // 42: dapr.proto.runtime.v1.TransactionalActorStateOperation + (*InvokeActorRequest)(nil), // 43: dapr.proto.runtime.v1.InvokeActorRequest + (*InvokeActorResponse)(nil), // 44: dapr.proto.runtime.v1.InvokeActorResponse + (*GetMetadataRequest)(nil), // 45: dapr.proto.runtime.v1.GetMetadataRequest + (*GetMetadataResponse)(nil), // 46: dapr.proto.runtime.v1.GetMetadataResponse + (*MetadataScheduler)(nil), // 47: dapr.proto.runtime.v1.MetadataScheduler + (*ActorRuntime)(nil), // 48: dapr.proto.runtime.v1.ActorRuntime + (*ActiveActorsCount)(nil), // 49: dapr.proto.runtime.v1.ActiveActorsCount + (*RegisteredComponents)(nil), // 50: dapr.proto.runtime.v1.RegisteredComponents + (*MetadataHTTPEndpoint)(nil), // 51: dapr.proto.runtime.v1.MetadataHTTPEndpoint + (*AppConnectionProperties)(nil), // 52: dapr.proto.runtime.v1.AppConnectionProperties + (*AppConnectionHealthProperties)(nil), // 53: dapr.proto.runtime.v1.AppConnectionHealthProperties + (*PubsubSubscription)(nil), // 54: dapr.proto.runtime.v1.PubsubSubscription + (*PubsubSubscriptionRules)(nil), // 55: dapr.proto.runtime.v1.PubsubSubscriptionRules + (*PubsubSubscriptionRule)(nil), // 56: dapr.proto.runtime.v1.PubsubSubscriptionRule + (*SetMetadataRequest)(nil), // 57: dapr.proto.runtime.v1.SetMetadataRequest + (*GetConfigurationRequest)(nil), // 58: dapr.proto.runtime.v1.GetConfigurationRequest + (*GetConfigurationResponse)(nil), // 59: dapr.proto.runtime.v1.GetConfigurationResponse + (*SubscribeConfigurationRequest)(nil), // 60: dapr.proto.runtime.v1.SubscribeConfigurationRequest + (*UnsubscribeConfigurationRequest)(nil), // 61: dapr.proto.runtime.v1.UnsubscribeConfigurationRequest + (*SubscribeConfigurationResponse)(nil), // 62: dapr.proto.runtime.v1.SubscribeConfigurationResponse + (*UnsubscribeConfigurationResponse)(nil), // 63: dapr.proto.runtime.v1.UnsubscribeConfigurationResponse + (*TryLockRequest)(nil), // 64: dapr.proto.runtime.v1.TryLockRequest + (*TryLockResponse)(nil), // 65: dapr.proto.runtime.v1.TryLockResponse + (*UnlockRequest)(nil), // 66: dapr.proto.runtime.v1.UnlockRequest + (*UnlockResponse)(nil), // 67: dapr.proto.runtime.v1.UnlockResponse + (*SubtleGetKeyRequest)(nil), // 68: dapr.proto.runtime.v1.SubtleGetKeyRequest + (*SubtleGetKeyResponse)(nil), // 69: dapr.proto.runtime.v1.SubtleGetKeyResponse + (*SubtleEncryptRequest)(nil), // 70: dapr.proto.runtime.v1.SubtleEncryptRequest + (*SubtleEncryptResponse)(nil), // 71: dapr.proto.runtime.v1.SubtleEncryptResponse + (*SubtleDecryptRequest)(nil), // 72: dapr.proto.runtime.v1.SubtleDecryptRequest + (*SubtleDecryptResponse)(nil), // 73: dapr.proto.runtime.v1.SubtleDecryptResponse + (*SubtleWrapKeyRequest)(nil), // 74: dapr.proto.runtime.v1.SubtleWrapKeyRequest + (*SubtleWrapKeyResponse)(nil), // 75: dapr.proto.runtime.v1.SubtleWrapKeyResponse + (*SubtleUnwrapKeyRequest)(nil), // 76: dapr.proto.runtime.v1.SubtleUnwrapKeyRequest + (*SubtleUnwrapKeyResponse)(nil), // 77: dapr.proto.runtime.v1.SubtleUnwrapKeyResponse + (*SubtleSignRequest)(nil), // 78: dapr.proto.runtime.v1.SubtleSignRequest + (*SubtleSignResponse)(nil), // 79: dapr.proto.runtime.v1.SubtleSignResponse + (*SubtleVerifyRequest)(nil), // 80: dapr.proto.runtime.v1.SubtleVerifyRequest + (*SubtleVerifyResponse)(nil), // 81: dapr.proto.runtime.v1.SubtleVerifyResponse + (*EncryptRequest)(nil), // 82: dapr.proto.runtime.v1.EncryptRequest + (*EncryptRequestOptions)(nil), // 83: dapr.proto.runtime.v1.EncryptRequestOptions + (*EncryptResponse)(nil), // 84: dapr.proto.runtime.v1.EncryptResponse + (*DecryptRequest)(nil), // 85: dapr.proto.runtime.v1.DecryptRequest + (*DecryptRequestOptions)(nil), // 86: dapr.proto.runtime.v1.DecryptRequestOptions + (*DecryptResponse)(nil), // 87: dapr.proto.runtime.v1.DecryptResponse + (*GetWorkflowRequest)(nil), // 88: dapr.proto.runtime.v1.GetWorkflowRequest + (*GetWorkflowResponse)(nil), // 89: dapr.proto.runtime.v1.GetWorkflowResponse + (*StartWorkflowRequest)(nil), // 90: dapr.proto.runtime.v1.StartWorkflowRequest + (*StartWorkflowResponse)(nil), // 91: dapr.proto.runtime.v1.StartWorkflowResponse + (*TerminateWorkflowRequest)(nil), // 92: dapr.proto.runtime.v1.TerminateWorkflowRequest + (*PauseWorkflowRequest)(nil), // 93: dapr.proto.runtime.v1.PauseWorkflowRequest + (*ResumeWorkflowRequest)(nil), // 94: dapr.proto.runtime.v1.ResumeWorkflowRequest + (*RaiseEventWorkflowRequest)(nil), // 95: dapr.proto.runtime.v1.RaiseEventWorkflowRequest + (*PurgeWorkflowRequest)(nil), // 96: dapr.proto.runtime.v1.PurgeWorkflowRequest + (*ShutdownRequest)(nil), // 97: dapr.proto.runtime.v1.ShutdownRequest + (*Job)(nil), // 98: dapr.proto.runtime.v1.Job + (*ScheduleJobRequest)(nil), // 99: dapr.proto.runtime.v1.ScheduleJobRequest + (*ScheduleJobResponse)(nil), // 100: dapr.proto.runtime.v1.ScheduleJobResponse + (*GetJobRequest)(nil), // 101: dapr.proto.runtime.v1.GetJobRequest + (*GetJobResponse)(nil), // 102: dapr.proto.runtime.v1.GetJobResponse + (*DeleteJobRequest)(nil), // 103: dapr.proto.runtime.v1.DeleteJobRequest + (*DeleteJobResponse)(nil), // 104: dapr.proto.runtime.v1.DeleteJobResponse + (*ConversationRequest)(nil), // 105: dapr.proto.runtime.v1.ConversationRequest + (*ConversationInput)(nil), // 106: dapr.proto.runtime.v1.ConversationInput + (*ConversationResult)(nil), // 107: dapr.proto.runtime.v1.ConversationResult + (*ConversationResponse)(nil), // 108: dapr.proto.runtime.v1.ConversationResponse + nil, // 109: dapr.proto.runtime.v1.GetStateRequest.MetadataEntry + nil, // 110: dapr.proto.runtime.v1.GetBulkStateRequest.MetadataEntry + nil, // 111: dapr.proto.runtime.v1.BulkStateItem.MetadataEntry + nil, // 112: dapr.proto.runtime.v1.GetStateResponse.MetadataEntry + nil, // 113: dapr.proto.runtime.v1.DeleteStateRequest.MetadataEntry + nil, // 114: dapr.proto.runtime.v1.QueryStateRequest.MetadataEntry + nil, // 115: dapr.proto.runtime.v1.QueryStateResponse.MetadataEntry + nil, // 116: dapr.proto.runtime.v1.PublishEventRequest.MetadataEntry + nil, // 117: dapr.proto.runtime.v1.BulkPublishRequest.MetadataEntry + nil, // 118: dapr.proto.runtime.v1.BulkPublishRequestEntry.MetadataEntry + nil, // 119: dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.MetadataEntry + nil, // 120: dapr.proto.runtime.v1.InvokeBindingRequest.MetadataEntry + nil, // 121: dapr.proto.runtime.v1.InvokeBindingResponse.MetadataEntry + nil, // 122: dapr.proto.runtime.v1.GetSecretRequest.MetadataEntry + nil, // 123: dapr.proto.runtime.v1.GetSecretResponse.DataEntry + nil, // 124: dapr.proto.runtime.v1.GetBulkSecretRequest.MetadataEntry + nil, // 125: dapr.proto.runtime.v1.SecretResponse.SecretsEntry + nil, // 126: dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry + nil, // 127: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.MetadataEntry + nil, // 128: dapr.proto.runtime.v1.GetActorStateResponse.MetadataEntry + nil, // 129: dapr.proto.runtime.v1.TransactionalActorStateOperation.MetadataEntry + nil, // 130: dapr.proto.runtime.v1.InvokeActorRequest.MetadataEntry + nil, // 131: dapr.proto.runtime.v1.GetMetadataResponse.ExtendedMetadataEntry + nil, // 132: dapr.proto.runtime.v1.PubsubSubscription.MetadataEntry + nil, // 133: dapr.proto.runtime.v1.GetConfigurationRequest.MetadataEntry + nil, // 134: dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry + nil, // 135: dapr.proto.runtime.v1.SubscribeConfigurationRequest.MetadataEntry + nil, // 136: dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry + nil, // 137: dapr.proto.runtime.v1.GetWorkflowResponse.PropertiesEntry + nil, // 138: dapr.proto.runtime.v1.StartWorkflowRequest.OptionsEntry + nil, // 139: dapr.proto.runtime.v1.ConversationRequest.ParametersEntry + nil, // 140: dapr.proto.runtime.v1.ConversationRequest.MetadataEntry + nil, // 141: dapr.proto.runtime.v1.ConversationResult.ParametersEntry + (*v1.InvokeRequest)(nil), // 142: dapr.proto.common.v1.InvokeRequest + (v1.StateOptions_StateConsistency)(0), // 143: dapr.proto.common.v1.StateOptions.StateConsistency + (*v1.Etag)(nil), // 144: dapr.proto.common.v1.Etag + (*v1.StateOptions)(nil), // 145: dapr.proto.common.v1.StateOptions + (*v1.StateItem)(nil), // 146: dapr.proto.common.v1.StateItem + (*TopicEventResponse)(nil), // 147: dapr.proto.runtime.v1.TopicEventResponse + (*TopicEventRequest)(nil), // 148: dapr.proto.runtime.v1.TopicEventRequest + (*anypb.Any)(nil), // 149: google.protobuf.Any + (*v1.StreamPayload)(nil), // 150: dapr.proto.common.v1.StreamPayload + (*timestamppb.Timestamp)(nil), // 151: google.protobuf.Timestamp + (*v1.JobFailurePolicy)(nil), // 152: dapr.proto.common.v1.JobFailurePolicy + (*v1.ConfigurationItem)(nil), // 153: dapr.proto.common.v1.ConfigurationItem + (*v1.InvokeResponse)(nil), // 154: dapr.proto.common.v1.InvokeResponse + (*emptypb.Empty)(nil), // 155: google.protobuf.Empty +} +var file_dapr_proto_runtime_v1_dapr_proto_depIdxs = []int32{ + 142, // 0: dapr.proto.runtime.v1.InvokeServiceRequest.message:type_name -> dapr.proto.common.v1.InvokeRequest + 143, // 1: dapr.proto.runtime.v1.GetStateRequest.consistency:type_name -> dapr.proto.common.v1.StateOptions.StateConsistency + 109, // 2: dapr.proto.runtime.v1.GetStateRequest.metadata:type_name -> dapr.proto.runtime.v1.GetStateRequest.MetadataEntry + 110, // 3: dapr.proto.runtime.v1.GetBulkStateRequest.metadata:type_name -> dapr.proto.runtime.v1.GetBulkStateRequest.MetadataEntry + 8, // 4: dapr.proto.runtime.v1.GetBulkStateResponse.items:type_name -> dapr.proto.runtime.v1.BulkStateItem + 111, // 5: dapr.proto.runtime.v1.BulkStateItem.metadata:type_name -> dapr.proto.runtime.v1.BulkStateItem.MetadataEntry + 112, // 6: dapr.proto.runtime.v1.GetStateResponse.metadata:type_name -> dapr.proto.runtime.v1.GetStateResponse.MetadataEntry + 144, // 7: dapr.proto.runtime.v1.DeleteStateRequest.etag:type_name -> dapr.proto.common.v1.Etag + 145, // 8: dapr.proto.runtime.v1.DeleteStateRequest.options:type_name -> dapr.proto.common.v1.StateOptions + 113, // 9: dapr.proto.runtime.v1.DeleteStateRequest.metadata:type_name -> dapr.proto.runtime.v1.DeleteStateRequest.MetadataEntry + 146, // 10: dapr.proto.runtime.v1.DeleteBulkStateRequest.states:type_name -> dapr.proto.common.v1.StateItem + 146, // 11: dapr.proto.runtime.v1.SaveStateRequest.states:type_name -> dapr.proto.common.v1.StateItem + 114, // 12: dapr.proto.runtime.v1.QueryStateRequest.metadata:type_name -> dapr.proto.runtime.v1.QueryStateRequest.MetadataEntry + 14, // 13: dapr.proto.runtime.v1.QueryStateResponse.results:type_name -> dapr.proto.runtime.v1.QueryStateItem + 115, // 14: dapr.proto.runtime.v1.QueryStateResponse.metadata:type_name -> dapr.proto.runtime.v1.QueryStateResponse.MetadataEntry + 116, // 15: dapr.proto.runtime.v1.PublishEventRequest.metadata:type_name -> dapr.proto.runtime.v1.PublishEventRequest.MetadataEntry + 18, // 16: dapr.proto.runtime.v1.BulkPublishRequest.entries:type_name -> dapr.proto.runtime.v1.BulkPublishRequestEntry + 117, // 17: dapr.proto.runtime.v1.BulkPublishRequest.metadata:type_name -> dapr.proto.runtime.v1.BulkPublishRequest.MetadataEntry + 118, // 18: dapr.proto.runtime.v1.BulkPublishRequestEntry.metadata:type_name -> dapr.proto.runtime.v1.BulkPublishRequestEntry.MetadataEntry + 20, // 19: dapr.proto.runtime.v1.BulkPublishResponse.failedEntries:type_name -> dapr.proto.runtime.v1.BulkPublishResponseFailedEntry + 22, // 20: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.initial_request:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1 + 23, // 21: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.event_processed:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1 + 119, // 22: dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.metadata:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.MetadataEntry + 147, // 23: dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse + 25, // 24: dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.initial_response:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1 + 148, // 25: dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.event_message:type_name -> dapr.proto.runtime.v1.TopicEventRequest + 120, // 26: dapr.proto.runtime.v1.InvokeBindingRequest.metadata:type_name -> dapr.proto.runtime.v1.InvokeBindingRequest.MetadataEntry + 121, // 27: dapr.proto.runtime.v1.InvokeBindingResponse.metadata:type_name -> dapr.proto.runtime.v1.InvokeBindingResponse.MetadataEntry + 122, // 28: dapr.proto.runtime.v1.GetSecretRequest.metadata:type_name -> dapr.proto.runtime.v1.GetSecretRequest.MetadataEntry + 123, // 29: dapr.proto.runtime.v1.GetSecretResponse.data:type_name -> dapr.proto.runtime.v1.GetSecretResponse.DataEntry + 124, // 30: dapr.proto.runtime.v1.GetBulkSecretRequest.metadata:type_name -> dapr.proto.runtime.v1.GetBulkSecretRequest.MetadataEntry + 125, // 31: dapr.proto.runtime.v1.SecretResponse.secrets:type_name -> dapr.proto.runtime.v1.SecretResponse.SecretsEntry + 126, // 32: dapr.proto.runtime.v1.GetBulkSecretResponse.data:type_name -> dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry + 146, // 33: dapr.proto.runtime.v1.TransactionalStateOperation.request:type_name -> dapr.proto.common.v1.StateItem + 33, // 34: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.operations:type_name -> dapr.proto.runtime.v1.TransactionalStateOperation + 127, // 35: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.metadata:type_name -> dapr.proto.runtime.v1.ExecuteStateTransactionRequest.MetadataEntry + 128, // 36: dapr.proto.runtime.v1.GetActorStateResponse.metadata:type_name -> dapr.proto.runtime.v1.GetActorStateResponse.MetadataEntry + 42, // 37: dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.operations:type_name -> dapr.proto.runtime.v1.TransactionalActorStateOperation + 149, // 38: dapr.proto.runtime.v1.TransactionalActorStateOperation.value:type_name -> google.protobuf.Any + 129, // 39: dapr.proto.runtime.v1.TransactionalActorStateOperation.metadata:type_name -> dapr.proto.runtime.v1.TransactionalActorStateOperation.MetadataEntry + 130, // 40: dapr.proto.runtime.v1.InvokeActorRequest.metadata:type_name -> dapr.proto.runtime.v1.InvokeActorRequest.MetadataEntry + 49, // 41: dapr.proto.runtime.v1.GetMetadataResponse.active_actors_count:type_name -> dapr.proto.runtime.v1.ActiveActorsCount + 50, // 42: dapr.proto.runtime.v1.GetMetadataResponse.registered_components:type_name -> dapr.proto.runtime.v1.RegisteredComponents + 131, // 43: dapr.proto.runtime.v1.GetMetadataResponse.extended_metadata:type_name -> dapr.proto.runtime.v1.GetMetadataResponse.ExtendedMetadataEntry + 54, // 44: dapr.proto.runtime.v1.GetMetadataResponse.subscriptions:type_name -> dapr.proto.runtime.v1.PubsubSubscription + 51, // 45: dapr.proto.runtime.v1.GetMetadataResponse.http_endpoints:type_name -> dapr.proto.runtime.v1.MetadataHTTPEndpoint + 52, // 46: dapr.proto.runtime.v1.GetMetadataResponse.app_connection_properties:type_name -> dapr.proto.runtime.v1.AppConnectionProperties + 48, // 47: dapr.proto.runtime.v1.GetMetadataResponse.actor_runtime:type_name -> dapr.proto.runtime.v1.ActorRuntime + 47, // 48: dapr.proto.runtime.v1.GetMetadataResponse.scheduler:type_name -> dapr.proto.runtime.v1.MetadataScheduler + 1, // 49: dapr.proto.runtime.v1.ActorRuntime.runtime_status:type_name -> dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus + 49, // 50: dapr.proto.runtime.v1.ActorRuntime.active_actors:type_name -> dapr.proto.runtime.v1.ActiveActorsCount + 53, // 51: dapr.proto.runtime.v1.AppConnectionProperties.health:type_name -> dapr.proto.runtime.v1.AppConnectionHealthProperties + 132, // 52: dapr.proto.runtime.v1.PubsubSubscription.metadata:type_name -> dapr.proto.runtime.v1.PubsubSubscription.MetadataEntry + 55, // 53: dapr.proto.runtime.v1.PubsubSubscription.rules:type_name -> dapr.proto.runtime.v1.PubsubSubscriptionRules + 0, // 54: dapr.proto.runtime.v1.PubsubSubscription.type:type_name -> dapr.proto.runtime.v1.PubsubSubscriptionType + 56, // 55: dapr.proto.runtime.v1.PubsubSubscriptionRules.rules:type_name -> dapr.proto.runtime.v1.PubsubSubscriptionRule + 133, // 56: dapr.proto.runtime.v1.GetConfigurationRequest.metadata:type_name -> dapr.proto.runtime.v1.GetConfigurationRequest.MetadataEntry + 134, // 57: dapr.proto.runtime.v1.GetConfigurationResponse.items:type_name -> dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry + 135, // 58: dapr.proto.runtime.v1.SubscribeConfigurationRequest.metadata:type_name -> dapr.proto.runtime.v1.SubscribeConfigurationRequest.MetadataEntry + 136, // 59: dapr.proto.runtime.v1.SubscribeConfigurationResponse.items:type_name -> dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry + 2, // 60: dapr.proto.runtime.v1.UnlockResponse.status:type_name -> dapr.proto.runtime.v1.UnlockResponse.Status + 3, // 61: dapr.proto.runtime.v1.SubtleGetKeyRequest.format:type_name -> dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat + 83, // 62: dapr.proto.runtime.v1.EncryptRequest.options:type_name -> dapr.proto.runtime.v1.EncryptRequestOptions + 150, // 63: dapr.proto.runtime.v1.EncryptRequest.payload:type_name -> dapr.proto.common.v1.StreamPayload + 150, // 64: dapr.proto.runtime.v1.EncryptResponse.payload:type_name -> dapr.proto.common.v1.StreamPayload + 86, // 65: dapr.proto.runtime.v1.DecryptRequest.options:type_name -> dapr.proto.runtime.v1.DecryptRequestOptions + 150, // 66: dapr.proto.runtime.v1.DecryptRequest.payload:type_name -> dapr.proto.common.v1.StreamPayload + 150, // 67: dapr.proto.runtime.v1.DecryptResponse.payload:type_name -> dapr.proto.common.v1.StreamPayload + 151, // 68: dapr.proto.runtime.v1.GetWorkflowResponse.created_at:type_name -> google.protobuf.Timestamp + 151, // 69: dapr.proto.runtime.v1.GetWorkflowResponse.last_updated_at:type_name -> google.protobuf.Timestamp + 137, // 70: dapr.proto.runtime.v1.GetWorkflowResponse.properties:type_name -> dapr.proto.runtime.v1.GetWorkflowResponse.PropertiesEntry + 138, // 71: dapr.proto.runtime.v1.StartWorkflowRequest.options:type_name -> dapr.proto.runtime.v1.StartWorkflowRequest.OptionsEntry + 149, // 72: dapr.proto.runtime.v1.Job.data:type_name -> google.protobuf.Any + 152, // 73: dapr.proto.runtime.v1.Job.failure_policy:type_name -> dapr.proto.common.v1.JobFailurePolicy + 98, // 74: dapr.proto.runtime.v1.ScheduleJobRequest.job:type_name -> dapr.proto.runtime.v1.Job + 98, // 75: dapr.proto.runtime.v1.GetJobResponse.job:type_name -> dapr.proto.runtime.v1.Job + 106, // 76: dapr.proto.runtime.v1.ConversationRequest.inputs:type_name -> dapr.proto.runtime.v1.ConversationInput + 139, // 77: dapr.proto.runtime.v1.ConversationRequest.parameters:type_name -> dapr.proto.runtime.v1.ConversationRequest.ParametersEntry + 140, // 78: dapr.proto.runtime.v1.ConversationRequest.metadata:type_name -> dapr.proto.runtime.v1.ConversationRequest.MetadataEntry + 141, // 79: dapr.proto.runtime.v1.ConversationResult.parameters:type_name -> dapr.proto.runtime.v1.ConversationResult.ParametersEntry + 107, // 80: dapr.proto.runtime.v1.ConversationResponse.outputs:type_name -> dapr.proto.runtime.v1.ConversationResult + 31, // 81: dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry.value:type_name -> dapr.proto.runtime.v1.SecretResponse + 153, // 82: dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry.value:type_name -> dapr.proto.common.v1.ConfigurationItem + 153, // 83: dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry.value:type_name -> dapr.proto.common.v1.ConfigurationItem + 149, // 84: dapr.proto.runtime.v1.ConversationRequest.ParametersEntry.value:type_name -> google.protobuf.Any + 149, // 85: dapr.proto.runtime.v1.ConversationResult.ParametersEntry.value:type_name -> google.protobuf.Any + 4, // 86: dapr.proto.runtime.v1.Dapr.InvokeService:input_type -> dapr.proto.runtime.v1.InvokeServiceRequest + 5, // 87: dapr.proto.runtime.v1.Dapr.GetState:input_type -> dapr.proto.runtime.v1.GetStateRequest + 6, // 88: dapr.proto.runtime.v1.Dapr.GetBulkState:input_type -> dapr.proto.runtime.v1.GetBulkStateRequest + 12, // 89: dapr.proto.runtime.v1.Dapr.SaveState:input_type -> dapr.proto.runtime.v1.SaveStateRequest + 13, // 90: dapr.proto.runtime.v1.Dapr.QueryStateAlpha1:input_type -> dapr.proto.runtime.v1.QueryStateRequest + 10, // 91: dapr.proto.runtime.v1.Dapr.DeleteState:input_type -> dapr.proto.runtime.v1.DeleteStateRequest + 11, // 92: dapr.proto.runtime.v1.Dapr.DeleteBulkState:input_type -> dapr.proto.runtime.v1.DeleteBulkStateRequest + 34, // 93: dapr.proto.runtime.v1.Dapr.ExecuteStateTransaction:input_type -> dapr.proto.runtime.v1.ExecuteStateTransactionRequest + 16, // 94: dapr.proto.runtime.v1.Dapr.PublishEvent:input_type -> dapr.proto.runtime.v1.PublishEventRequest + 17, // 95: dapr.proto.runtime.v1.Dapr.BulkPublishEventAlpha1:input_type -> dapr.proto.runtime.v1.BulkPublishRequest + 21, // 96: dapr.proto.runtime.v1.Dapr.SubscribeTopicEventsAlpha1:input_type -> dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1 + 26, // 97: dapr.proto.runtime.v1.Dapr.InvokeBinding:input_type -> dapr.proto.runtime.v1.InvokeBindingRequest + 28, // 98: dapr.proto.runtime.v1.Dapr.GetSecret:input_type -> dapr.proto.runtime.v1.GetSecretRequest + 30, // 99: dapr.proto.runtime.v1.Dapr.GetBulkSecret:input_type -> dapr.proto.runtime.v1.GetBulkSecretRequest + 35, // 100: dapr.proto.runtime.v1.Dapr.RegisterActorTimer:input_type -> dapr.proto.runtime.v1.RegisterActorTimerRequest + 36, // 101: dapr.proto.runtime.v1.Dapr.UnregisterActorTimer:input_type -> dapr.proto.runtime.v1.UnregisterActorTimerRequest + 37, // 102: dapr.proto.runtime.v1.Dapr.RegisterActorReminder:input_type -> dapr.proto.runtime.v1.RegisterActorReminderRequest + 38, // 103: dapr.proto.runtime.v1.Dapr.UnregisterActorReminder:input_type -> dapr.proto.runtime.v1.UnregisterActorReminderRequest + 39, // 104: dapr.proto.runtime.v1.Dapr.GetActorState:input_type -> dapr.proto.runtime.v1.GetActorStateRequest + 41, // 105: dapr.proto.runtime.v1.Dapr.ExecuteActorStateTransaction:input_type -> dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest + 43, // 106: dapr.proto.runtime.v1.Dapr.InvokeActor:input_type -> dapr.proto.runtime.v1.InvokeActorRequest + 58, // 107: dapr.proto.runtime.v1.Dapr.GetConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.GetConfigurationRequest + 58, // 108: dapr.proto.runtime.v1.Dapr.GetConfiguration:input_type -> dapr.proto.runtime.v1.GetConfigurationRequest + 60, // 109: dapr.proto.runtime.v1.Dapr.SubscribeConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.SubscribeConfigurationRequest + 60, // 110: dapr.proto.runtime.v1.Dapr.SubscribeConfiguration:input_type -> dapr.proto.runtime.v1.SubscribeConfigurationRequest + 61, // 111: dapr.proto.runtime.v1.Dapr.UnsubscribeConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationRequest + 61, // 112: dapr.proto.runtime.v1.Dapr.UnsubscribeConfiguration:input_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationRequest + 64, // 113: dapr.proto.runtime.v1.Dapr.TryLockAlpha1:input_type -> dapr.proto.runtime.v1.TryLockRequest + 66, // 114: dapr.proto.runtime.v1.Dapr.UnlockAlpha1:input_type -> dapr.proto.runtime.v1.UnlockRequest + 82, // 115: dapr.proto.runtime.v1.Dapr.EncryptAlpha1:input_type -> dapr.proto.runtime.v1.EncryptRequest + 85, // 116: dapr.proto.runtime.v1.Dapr.DecryptAlpha1:input_type -> dapr.proto.runtime.v1.DecryptRequest + 45, // 117: dapr.proto.runtime.v1.Dapr.GetMetadata:input_type -> dapr.proto.runtime.v1.GetMetadataRequest + 57, // 118: dapr.proto.runtime.v1.Dapr.SetMetadata:input_type -> dapr.proto.runtime.v1.SetMetadataRequest + 68, // 119: dapr.proto.runtime.v1.Dapr.SubtleGetKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleGetKeyRequest + 70, // 120: dapr.proto.runtime.v1.Dapr.SubtleEncryptAlpha1:input_type -> dapr.proto.runtime.v1.SubtleEncryptRequest + 72, // 121: dapr.proto.runtime.v1.Dapr.SubtleDecryptAlpha1:input_type -> dapr.proto.runtime.v1.SubtleDecryptRequest + 74, // 122: dapr.proto.runtime.v1.Dapr.SubtleWrapKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleWrapKeyRequest + 76, // 123: dapr.proto.runtime.v1.Dapr.SubtleUnwrapKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleUnwrapKeyRequest + 78, // 124: dapr.proto.runtime.v1.Dapr.SubtleSignAlpha1:input_type -> dapr.proto.runtime.v1.SubtleSignRequest + 80, // 125: dapr.proto.runtime.v1.Dapr.SubtleVerifyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleVerifyRequest + 90, // 126: dapr.proto.runtime.v1.Dapr.StartWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.StartWorkflowRequest + 88, // 127: dapr.proto.runtime.v1.Dapr.GetWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.GetWorkflowRequest + 96, // 128: dapr.proto.runtime.v1.Dapr.PurgeWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.PurgeWorkflowRequest + 92, // 129: dapr.proto.runtime.v1.Dapr.TerminateWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.TerminateWorkflowRequest + 93, // 130: dapr.proto.runtime.v1.Dapr.PauseWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.PauseWorkflowRequest + 94, // 131: dapr.proto.runtime.v1.Dapr.ResumeWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.ResumeWorkflowRequest + 95, // 132: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.RaiseEventWorkflowRequest + 90, // 133: dapr.proto.runtime.v1.Dapr.StartWorkflowBeta1:input_type -> dapr.proto.runtime.v1.StartWorkflowRequest + 88, // 134: dapr.proto.runtime.v1.Dapr.GetWorkflowBeta1:input_type -> dapr.proto.runtime.v1.GetWorkflowRequest + 96, // 135: dapr.proto.runtime.v1.Dapr.PurgeWorkflowBeta1:input_type -> dapr.proto.runtime.v1.PurgeWorkflowRequest + 92, // 136: dapr.proto.runtime.v1.Dapr.TerminateWorkflowBeta1:input_type -> dapr.proto.runtime.v1.TerminateWorkflowRequest + 93, // 137: dapr.proto.runtime.v1.Dapr.PauseWorkflowBeta1:input_type -> dapr.proto.runtime.v1.PauseWorkflowRequest + 94, // 138: dapr.proto.runtime.v1.Dapr.ResumeWorkflowBeta1:input_type -> dapr.proto.runtime.v1.ResumeWorkflowRequest + 95, // 139: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowBeta1:input_type -> dapr.proto.runtime.v1.RaiseEventWorkflowRequest + 97, // 140: dapr.proto.runtime.v1.Dapr.Shutdown:input_type -> dapr.proto.runtime.v1.ShutdownRequest + 99, // 141: dapr.proto.runtime.v1.Dapr.ScheduleJobAlpha1:input_type -> dapr.proto.runtime.v1.ScheduleJobRequest + 101, // 142: dapr.proto.runtime.v1.Dapr.GetJobAlpha1:input_type -> dapr.proto.runtime.v1.GetJobRequest + 103, // 143: dapr.proto.runtime.v1.Dapr.DeleteJobAlpha1:input_type -> dapr.proto.runtime.v1.DeleteJobRequest + 105, // 144: dapr.proto.runtime.v1.Dapr.ConverseAlpha1:input_type -> dapr.proto.runtime.v1.ConversationRequest + 154, // 145: dapr.proto.runtime.v1.Dapr.InvokeService:output_type -> dapr.proto.common.v1.InvokeResponse + 9, // 146: dapr.proto.runtime.v1.Dapr.GetState:output_type -> dapr.proto.runtime.v1.GetStateResponse + 7, // 147: dapr.proto.runtime.v1.Dapr.GetBulkState:output_type -> dapr.proto.runtime.v1.GetBulkStateResponse + 155, // 148: dapr.proto.runtime.v1.Dapr.SaveState:output_type -> google.protobuf.Empty + 15, // 149: dapr.proto.runtime.v1.Dapr.QueryStateAlpha1:output_type -> dapr.proto.runtime.v1.QueryStateResponse + 155, // 150: dapr.proto.runtime.v1.Dapr.DeleteState:output_type -> google.protobuf.Empty + 155, // 151: dapr.proto.runtime.v1.Dapr.DeleteBulkState:output_type -> google.protobuf.Empty + 155, // 152: dapr.proto.runtime.v1.Dapr.ExecuteStateTransaction:output_type -> google.protobuf.Empty + 155, // 153: dapr.proto.runtime.v1.Dapr.PublishEvent:output_type -> google.protobuf.Empty + 19, // 154: dapr.proto.runtime.v1.Dapr.BulkPublishEventAlpha1:output_type -> dapr.proto.runtime.v1.BulkPublishResponse + 24, // 155: dapr.proto.runtime.v1.Dapr.SubscribeTopicEventsAlpha1:output_type -> dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1 + 27, // 156: dapr.proto.runtime.v1.Dapr.InvokeBinding:output_type -> dapr.proto.runtime.v1.InvokeBindingResponse + 29, // 157: dapr.proto.runtime.v1.Dapr.GetSecret:output_type -> dapr.proto.runtime.v1.GetSecretResponse + 32, // 158: dapr.proto.runtime.v1.Dapr.GetBulkSecret:output_type -> dapr.proto.runtime.v1.GetBulkSecretResponse + 155, // 159: dapr.proto.runtime.v1.Dapr.RegisterActorTimer:output_type -> google.protobuf.Empty + 155, // 160: dapr.proto.runtime.v1.Dapr.UnregisterActorTimer:output_type -> google.protobuf.Empty + 155, // 161: dapr.proto.runtime.v1.Dapr.RegisterActorReminder:output_type -> google.protobuf.Empty + 155, // 162: dapr.proto.runtime.v1.Dapr.UnregisterActorReminder:output_type -> google.protobuf.Empty + 40, // 163: dapr.proto.runtime.v1.Dapr.GetActorState:output_type -> dapr.proto.runtime.v1.GetActorStateResponse + 155, // 164: dapr.proto.runtime.v1.Dapr.ExecuteActorStateTransaction:output_type -> google.protobuf.Empty + 44, // 165: dapr.proto.runtime.v1.Dapr.InvokeActor:output_type -> dapr.proto.runtime.v1.InvokeActorResponse + 59, // 166: dapr.proto.runtime.v1.Dapr.GetConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.GetConfigurationResponse + 59, // 167: dapr.proto.runtime.v1.Dapr.GetConfiguration:output_type -> dapr.proto.runtime.v1.GetConfigurationResponse + 62, // 168: dapr.proto.runtime.v1.Dapr.SubscribeConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.SubscribeConfigurationResponse + 62, // 169: dapr.proto.runtime.v1.Dapr.SubscribeConfiguration:output_type -> dapr.proto.runtime.v1.SubscribeConfigurationResponse + 63, // 170: dapr.proto.runtime.v1.Dapr.UnsubscribeConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationResponse + 63, // 171: dapr.proto.runtime.v1.Dapr.UnsubscribeConfiguration:output_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationResponse + 65, // 172: dapr.proto.runtime.v1.Dapr.TryLockAlpha1:output_type -> dapr.proto.runtime.v1.TryLockResponse + 67, // 173: dapr.proto.runtime.v1.Dapr.UnlockAlpha1:output_type -> dapr.proto.runtime.v1.UnlockResponse + 84, // 174: dapr.proto.runtime.v1.Dapr.EncryptAlpha1:output_type -> dapr.proto.runtime.v1.EncryptResponse + 87, // 175: dapr.proto.runtime.v1.Dapr.DecryptAlpha1:output_type -> dapr.proto.runtime.v1.DecryptResponse + 46, // 176: dapr.proto.runtime.v1.Dapr.GetMetadata:output_type -> dapr.proto.runtime.v1.GetMetadataResponse + 155, // 177: dapr.proto.runtime.v1.Dapr.SetMetadata:output_type -> google.protobuf.Empty + 69, // 178: dapr.proto.runtime.v1.Dapr.SubtleGetKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleGetKeyResponse + 71, // 179: dapr.proto.runtime.v1.Dapr.SubtleEncryptAlpha1:output_type -> dapr.proto.runtime.v1.SubtleEncryptResponse + 73, // 180: dapr.proto.runtime.v1.Dapr.SubtleDecryptAlpha1:output_type -> dapr.proto.runtime.v1.SubtleDecryptResponse + 75, // 181: dapr.proto.runtime.v1.Dapr.SubtleWrapKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleWrapKeyResponse + 77, // 182: dapr.proto.runtime.v1.Dapr.SubtleUnwrapKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleUnwrapKeyResponse + 79, // 183: dapr.proto.runtime.v1.Dapr.SubtleSignAlpha1:output_type -> dapr.proto.runtime.v1.SubtleSignResponse + 81, // 184: dapr.proto.runtime.v1.Dapr.SubtleVerifyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleVerifyResponse + 91, // 185: dapr.proto.runtime.v1.Dapr.StartWorkflowAlpha1:output_type -> dapr.proto.runtime.v1.StartWorkflowResponse + 89, // 186: dapr.proto.runtime.v1.Dapr.GetWorkflowAlpha1:output_type -> dapr.proto.runtime.v1.GetWorkflowResponse + 155, // 187: dapr.proto.runtime.v1.Dapr.PurgeWorkflowAlpha1:output_type -> google.protobuf.Empty + 155, // 188: dapr.proto.runtime.v1.Dapr.TerminateWorkflowAlpha1:output_type -> google.protobuf.Empty + 155, // 189: dapr.proto.runtime.v1.Dapr.PauseWorkflowAlpha1:output_type -> google.protobuf.Empty + 155, // 190: dapr.proto.runtime.v1.Dapr.ResumeWorkflowAlpha1:output_type -> google.protobuf.Empty + 155, // 191: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowAlpha1:output_type -> google.protobuf.Empty + 91, // 192: dapr.proto.runtime.v1.Dapr.StartWorkflowBeta1:output_type -> dapr.proto.runtime.v1.StartWorkflowResponse + 89, // 193: dapr.proto.runtime.v1.Dapr.GetWorkflowBeta1:output_type -> dapr.proto.runtime.v1.GetWorkflowResponse + 155, // 194: dapr.proto.runtime.v1.Dapr.PurgeWorkflowBeta1:output_type -> google.protobuf.Empty + 155, // 195: dapr.proto.runtime.v1.Dapr.TerminateWorkflowBeta1:output_type -> google.protobuf.Empty + 155, // 196: dapr.proto.runtime.v1.Dapr.PauseWorkflowBeta1:output_type -> google.protobuf.Empty + 155, // 197: dapr.proto.runtime.v1.Dapr.ResumeWorkflowBeta1:output_type -> google.protobuf.Empty + 155, // 198: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowBeta1:output_type -> google.protobuf.Empty + 155, // 199: dapr.proto.runtime.v1.Dapr.Shutdown:output_type -> google.protobuf.Empty + 100, // 200: dapr.proto.runtime.v1.Dapr.ScheduleJobAlpha1:output_type -> dapr.proto.runtime.v1.ScheduleJobResponse + 102, // 201: dapr.proto.runtime.v1.Dapr.GetJobAlpha1:output_type -> dapr.proto.runtime.v1.GetJobResponse + 104, // 202: dapr.proto.runtime.v1.Dapr.DeleteJobAlpha1:output_type -> dapr.proto.runtime.v1.DeleteJobResponse + 108, // 203: dapr.proto.runtime.v1.Dapr.ConverseAlpha1:output_type -> dapr.proto.runtime.v1.ConversationResponse + 145, // [145:204] is the sub-list for method output_type + 86, // [86:145] is the sub-list for method input_type + 86, // [86:86] is the sub-list for extension type_name + 86, // [86:86] is the sub-list for extension extendee + 0, // [0:86] is the sub-list for field type_name +} + +func init() { file_dapr_proto_runtime_v1_dapr_proto_init() } +func file_dapr_proto_runtime_v1_dapr_proto_init() { + if File_dapr_proto_runtime_v1_dapr_proto != nil { + return + } + file_dapr_proto_runtime_v1_appcallback_proto_init() + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17].OneofWrappers = []any{ + (*SubscribeTopicEventsRequestAlpha1_InitialRequest)(nil), + (*SubscribeTopicEventsRequestAlpha1_EventProcessed)(nil), + } + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18].OneofWrappers = []any{} + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20].OneofWrappers = []any{ + (*SubscribeTopicEventsResponseAlpha1_InitialResponse)(nil), + (*SubscribeTopicEventsResponseAlpha1_EventMessage)(nil), + } + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42].OneofWrappers = []any{} + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[94].OneofWrappers = []any{} + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[101].OneofWrappers = []any{} + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[102].OneofWrappers = []any{} + file_dapr_proto_runtime_v1_dapr_proto_msgTypes[104].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_dapr_proto_runtime_v1_dapr_proto_rawDesc), len(file_dapr_proto_runtime_v1_dapr_proto_rawDesc)), + NumEnums: 4, + NumMessages: 138, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_dapr_proto_runtime_v1_dapr_proto_goTypes, + DependencyIndexes: file_dapr_proto_runtime_v1_dapr_proto_depIdxs, + EnumInfos: file_dapr_proto_runtime_v1_dapr_proto_enumTypes, + MessageInfos: file_dapr_proto_runtime_v1_dapr_proto_msgTypes, + }.Build() + File_dapr_proto_runtime_v1_dapr_proto = out.File + file_dapr_proto_runtime_v1_dapr_proto_goTypes = nil + file_dapr_proto_runtime_v1_dapr_proto_depIdxs = nil +} diff --git a/internal/proto/dapr/proto/runtime/v1/dapr_grpc.pb.go b/internal/proto/dapr/proto/runtime/v1/dapr_grpc.pb.go new file mode 100644 index 00000000..469eea2e --- /dev/null +++ b/internal/proto/dapr/proto/runtime/v1/dapr_grpc.pb.go @@ -0,0 +1,2475 @@ +// +//Copyright 2021 The Dapr Authors +//Licensed under the Apache License, Version 2.0 (the "License"); +//you may not use this file except in compliance with the License. +//You may obtain a copy of the License at +//http://www.apache.org/licenses/LICENSE-2.0 +//Unless required by applicable law or agreed to in writing, software +//distributed under the License is distributed on an "AS IS" BASIS, +//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +//See the License for the specific language governing permissions and +//limitations under the License. + +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc (unknown) +// source: dapr/proto/runtime/v1/dapr.proto + +package runtimev1 + +import ( + context "context" + v1 "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + emptypb "google.golang.org/protobuf/types/known/emptypb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Dapr_InvokeService_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeService" + Dapr_GetState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetState" + Dapr_GetBulkState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetBulkState" + Dapr_SaveState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SaveState" + Dapr_QueryStateAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/QueryStateAlpha1" + Dapr_DeleteState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DeleteState" + Dapr_DeleteBulkState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DeleteBulkState" + Dapr_ExecuteStateTransaction_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ExecuteStateTransaction" + Dapr_PublishEvent_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PublishEvent" + Dapr_BulkPublishEventAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/BulkPublishEventAlpha1" + Dapr_SubscribeTopicEventsAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeTopicEventsAlpha1" + Dapr_InvokeBinding_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeBinding" + Dapr_GetSecret_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetSecret" + Dapr_GetBulkSecret_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetBulkSecret" + Dapr_RegisterActorTimer_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RegisterActorTimer" + Dapr_UnregisterActorTimer_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnregisterActorTimer" + Dapr_RegisterActorReminder_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RegisterActorReminder" + Dapr_UnregisterActorReminder_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnregisterActorReminder" + Dapr_GetActorState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetActorState" + Dapr_ExecuteActorStateTransaction_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ExecuteActorStateTransaction" + Dapr_InvokeActor_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeActor" + Dapr_GetConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetConfigurationAlpha1" + Dapr_GetConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetConfiguration" + Dapr_SubscribeConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeConfigurationAlpha1" + Dapr_SubscribeConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeConfiguration" + Dapr_UnsubscribeConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfigurationAlpha1" + Dapr_UnsubscribeConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfiguration" + Dapr_TryLockAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TryLockAlpha1" + Dapr_UnlockAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnlockAlpha1" + Dapr_EncryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/EncryptAlpha1" + Dapr_DecryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DecryptAlpha1" + Dapr_GetMetadata_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetMetadata" + Dapr_SetMetadata_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SetMetadata" + Dapr_SubtleGetKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleGetKeyAlpha1" + Dapr_SubtleEncryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleEncryptAlpha1" + Dapr_SubtleDecryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleDecryptAlpha1" + Dapr_SubtleWrapKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleWrapKeyAlpha1" + Dapr_SubtleUnwrapKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleUnwrapKeyAlpha1" + Dapr_SubtleSignAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleSignAlpha1" + Dapr_SubtleVerifyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleVerifyAlpha1" + Dapr_StartWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/StartWorkflowAlpha1" + Dapr_GetWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetWorkflowAlpha1" + Dapr_PurgeWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowAlpha1" + Dapr_TerminateWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowAlpha1" + Dapr_PauseWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PauseWorkflowAlpha1" + Dapr_ResumeWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowAlpha1" + Dapr_RaiseEventWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowAlpha1" + Dapr_StartWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/StartWorkflowBeta1" + Dapr_GetWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetWorkflowBeta1" + Dapr_PurgeWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowBeta1" + Dapr_TerminateWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowBeta1" + Dapr_PauseWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PauseWorkflowBeta1" + Dapr_ResumeWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowBeta1" + Dapr_RaiseEventWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowBeta1" + Dapr_Shutdown_FullMethodName = "/dapr.proto.runtime.v1.Dapr/Shutdown" + Dapr_ScheduleJobAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ScheduleJobAlpha1" + Dapr_GetJobAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetJobAlpha1" + Dapr_DeleteJobAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DeleteJobAlpha1" + Dapr_ConverseAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ConverseAlpha1" +) + +// DaprClient is the client API for Dapr service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// Dapr service provides APIs to user application to access Dapr building blocks. +type DaprClient interface { + // Invokes a method on a remote Dapr app. + // Deprecated: Use proxy mode service invocation instead. + InvokeService(ctx context.Context, in *InvokeServiceRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) + // Gets the state for a specific key. + GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error) + // Gets a bulk of state items for a list of keys + GetBulkState(ctx context.Context, in *GetBulkStateRequest, opts ...grpc.CallOption) (*GetBulkStateResponse, error) + // Saves the state for a specific key. + SaveState(ctx context.Context, in *SaveStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Queries the state. + QueryStateAlpha1(ctx context.Context, in *QueryStateRequest, opts ...grpc.CallOption) (*QueryStateResponse, error) + // Deletes the state for a specific key. + DeleteState(ctx context.Context, in *DeleteStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Deletes a bulk of state items for a list of keys + DeleteBulkState(ctx context.Context, in *DeleteBulkStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Executes transactions for a specified store + ExecuteStateTransaction(ctx context.Context, in *ExecuteStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Publishes events to the specific topic. + PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Bulk Publishes multiple events to the specified topic. + BulkPublishEventAlpha1(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error) + // SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic + // events from it. + SubscribeTopicEventsAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1], error) + // Invokes binding data to specific output bindings + InvokeBinding(ctx context.Context, in *InvokeBindingRequest, opts ...grpc.CallOption) (*InvokeBindingResponse, error) + // Gets secrets from secret stores. + GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) + // Gets a bulk of secrets + GetBulkSecret(ctx context.Context, in *GetBulkSecretRequest, opts ...grpc.CallOption) (*GetBulkSecretResponse, error) + // Register an actor timer. + RegisterActorTimer(ctx context.Context, in *RegisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Unregister an actor timer. + UnregisterActorTimer(ctx context.Context, in *UnregisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Register an actor reminder. + RegisterActorReminder(ctx context.Context, in *RegisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Unregister an actor reminder. + UnregisterActorReminder(ctx context.Context, in *UnregisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Gets the state for a specific actor. + GetActorState(ctx context.Context, in *GetActorStateRequest, opts ...grpc.CallOption) (*GetActorStateResponse, error) + // Executes state transactions for a specified actor + ExecuteActorStateTransaction(ctx context.Context, in *ExecuteActorStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // InvokeActor calls a method on an actor. + InvokeActor(ctx context.Context, in *InvokeActorRequest, opts ...grpc.CallOption) (*InvokeActorResponse, error) + // GetConfiguration gets configuration from configuration store. + GetConfigurationAlpha1(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) + // GetConfiguration gets configuration from configuration store. + GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) + // SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + SubscribeConfigurationAlpha1(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SubscribeConfigurationResponse], error) + // SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + SubscribeConfiguration(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SubscribeConfigurationResponse], error) + // UnSubscribeConfiguration unsubscribe the subscription of configuration + UnsubscribeConfigurationAlpha1(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) + // UnSubscribeConfiguration unsubscribe the subscription of configuration + UnsubscribeConfiguration(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) + // TryLockAlpha1 tries to get a lock with an expiry. + TryLockAlpha1(ctx context.Context, in *TryLockRequest, opts ...grpc.CallOption) (*TryLockResponse, error) + // UnlockAlpha1 unlocks a lock. + UnlockAlpha1(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) + // EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault. + EncryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[EncryptRequest, EncryptResponse], error) + // DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault. + DecryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DecryptRequest, DecryptResponse], error) + // Gets metadata of the sidecar + GetMetadata(ctx context.Context, in *GetMetadataRequest, opts ...grpc.CallOption) (*GetMetadataResponse, error) + // Sets value in extended metadata of the sidecar + SetMetadata(ctx context.Context, in *SetMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault. + SubtleGetKeyAlpha1(ctx context.Context, in *SubtleGetKeyRequest, opts ...grpc.CallOption) (*SubtleGetKeyResponse, error) + // SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault. + SubtleEncryptAlpha1(ctx context.Context, in *SubtleEncryptRequest, opts ...grpc.CallOption) (*SubtleEncryptResponse, error) + // SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault. + SubtleDecryptAlpha1(ctx context.Context, in *SubtleDecryptRequest, opts ...grpc.CallOption) (*SubtleDecryptResponse, error) + // SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault. + SubtleWrapKeyAlpha1(ctx context.Context, in *SubtleWrapKeyRequest, opts ...grpc.CallOption) (*SubtleWrapKeyResponse, error) + // SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault. + SubtleUnwrapKeyAlpha1(ctx context.Context, in *SubtleUnwrapKeyRequest, opts ...grpc.CallOption) (*SubtleUnwrapKeyResponse, error) + // SubtleSignAlpha1 signs a message using a key stored in the vault. + SubtleSignAlpha1(ctx context.Context, in *SubtleSignRequest, opts ...grpc.CallOption) (*SubtleSignResponse, error) + // SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault. + SubtleVerifyAlpha1(ctx context.Context, in *SubtleVerifyRequest, opts ...grpc.CallOption) (*SubtleVerifyResponse, error) + // Deprecated: Do not use. + // Starts a new instance of a workflow + StartWorkflowAlpha1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) + // Deprecated: Do not use. + // Gets details about a started workflow instance + GetWorkflowAlpha1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) + // Deprecated: Do not use. + // Purge Workflow + PurgeWorkflowAlpha1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Terminates a running workflow instance + TerminateWorkflowAlpha1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Pauses a running workflow instance + PauseWorkflowAlpha1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Resumes a paused workflow instance + ResumeWorkflowAlpha1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Raise an event to a running workflow instance + RaiseEventWorkflowAlpha1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Starts a new instance of a workflow + StartWorkflowBeta1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) + // Gets details about a started workflow instance + GetWorkflowBeta1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) + // Purge Workflow + PurgeWorkflowBeta1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Terminates a running workflow instance + TerminateWorkflowBeta1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Pauses a running workflow instance + PauseWorkflowBeta1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Resumes a paused workflow instance + ResumeWorkflowBeta1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Raise an event to a running workflow instance + RaiseEventWorkflowBeta1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Shutdown the sidecar + Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // Create and schedule a job + ScheduleJobAlpha1(ctx context.Context, in *ScheduleJobRequest, opts ...grpc.CallOption) (*ScheduleJobResponse, error) + // Gets a scheduled job + GetJobAlpha1(ctx context.Context, in *GetJobRequest, opts ...grpc.CallOption) (*GetJobResponse, error) + // Delete a job + DeleteJobAlpha1(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*DeleteJobResponse, error) + // Converse with a LLM service + ConverseAlpha1(ctx context.Context, in *ConversationRequest, opts ...grpc.CallOption) (*ConversationResponse, error) +} + +type daprClient struct { + cc grpc.ClientConnInterface +} + +func NewDaprClient(cc grpc.ClientConnInterface) DaprClient { + return &daprClient{cc} +} + +func (c *daprClient) InvokeService(ctx context.Context, in *InvokeServiceRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(v1.InvokeResponse) + err := c.cc.Invoke(ctx, Dapr_InvokeService_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetStateResponse) + err := c.cc.Invoke(ctx, Dapr_GetState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetBulkState(ctx context.Context, in *GetBulkStateRequest, opts ...grpc.CallOption) (*GetBulkStateResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetBulkStateResponse) + err := c.cc.Invoke(ctx, Dapr_GetBulkState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SaveState(ctx context.Context, in *SaveStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_SaveState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) QueryStateAlpha1(ctx context.Context, in *QueryStateRequest, opts ...grpc.CallOption) (*QueryStateResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(QueryStateResponse) + err := c.cc.Invoke(ctx, Dapr_QueryStateAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) DeleteState(ctx context.Context, in *DeleteStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_DeleteState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) DeleteBulkState(ctx context.Context, in *DeleteBulkStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_DeleteBulkState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) ExecuteStateTransaction(ctx context.Context, in *ExecuteStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_ExecuteStateTransaction_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_PublishEvent_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) BulkPublishEventAlpha1(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BulkPublishResponse) + err := c.cc.Invoke(ctx, Dapr_BulkPublishEventAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubscribeTopicEventsAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[0], Dapr_SubscribeTopicEventsAlpha1_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1]{ClientStream: stream} + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeTopicEventsAlpha1Client = grpc.BidiStreamingClient[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1] + +func (c *daprClient) InvokeBinding(ctx context.Context, in *InvokeBindingRequest, opts ...grpc.CallOption) (*InvokeBindingResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(InvokeBindingResponse) + err := c.cc.Invoke(ctx, Dapr_InvokeBinding_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetSecretResponse) + err := c.cc.Invoke(ctx, Dapr_GetSecret_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetBulkSecret(ctx context.Context, in *GetBulkSecretRequest, opts ...grpc.CallOption) (*GetBulkSecretResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetBulkSecretResponse) + err := c.cc.Invoke(ctx, Dapr_GetBulkSecret_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) RegisterActorTimer(ctx context.Context, in *RegisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_RegisterActorTimer_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) UnregisterActorTimer(ctx context.Context, in *UnregisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_UnregisterActorTimer_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) RegisterActorReminder(ctx context.Context, in *RegisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_RegisterActorReminder_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) UnregisterActorReminder(ctx context.Context, in *UnregisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_UnregisterActorReminder_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetActorState(ctx context.Context, in *GetActorStateRequest, opts ...grpc.CallOption) (*GetActorStateResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetActorStateResponse) + err := c.cc.Invoke(ctx, Dapr_GetActorState_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) ExecuteActorStateTransaction(ctx context.Context, in *ExecuteActorStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_ExecuteActorStateTransaction_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) InvokeActor(ctx context.Context, in *InvokeActorRequest, opts ...grpc.CallOption) (*InvokeActorResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(InvokeActorResponse) + err := c.cc.Invoke(ctx, Dapr_InvokeActor_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetConfigurationAlpha1(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetConfigurationResponse) + err := c.cc.Invoke(ctx, Dapr_GetConfigurationAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetConfigurationResponse) + err := c.cc.Invoke(ctx, Dapr_GetConfiguration_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubscribeConfigurationAlpha1(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SubscribeConfigurationResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[1], Dapr_SubscribeConfigurationAlpha1_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SubscribeConfigurationRequest, SubscribeConfigurationResponse]{ClientStream: stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeConfigurationAlpha1Client = grpc.ServerStreamingClient[SubscribeConfigurationResponse] + +func (c *daprClient) SubscribeConfiguration(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SubscribeConfigurationResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[2], Dapr_SubscribeConfiguration_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[SubscribeConfigurationRequest, SubscribeConfigurationResponse]{ClientStream: stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeConfigurationClient = grpc.ServerStreamingClient[SubscribeConfigurationResponse] + +func (c *daprClient) UnsubscribeConfigurationAlpha1(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(UnsubscribeConfigurationResponse) + err := c.cc.Invoke(ctx, Dapr_UnsubscribeConfigurationAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) UnsubscribeConfiguration(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(UnsubscribeConfigurationResponse) + err := c.cc.Invoke(ctx, Dapr_UnsubscribeConfiguration_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) TryLockAlpha1(ctx context.Context, in *TryLockRequest, opts ...grpc.CallOption) (*TryLockResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TryLockResponse) + err := c.cc.Invoke(ctx, Dapr_TryLockAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) UnlockAlpha1(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(UnlockResponse) + err := c.cc.Invoke(ctx, Dapr_UnlockAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) EncryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[EncryptRequest, EncryptResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[3], Dapr_EncryptAlpha1_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[EncryptRequest, EncryptResponse]{ClientStream: stream} + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_EncryptAlpha1Client = grpc.BidiStreamingClient[EncryptRequest, EncryptResponse] + +func (c *daprClient) DecryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DecryptRequest, DecryptResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[4], Dapr_DecryptAlpha1_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[DecryptRequest, DecryptResponse]{ClientStream: stream} + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_DecryptAlpha1Client = grpc.BidiStreamingClient[DecryptRequest, DecryptResponse] + +func (c *daprClient) GetMetadata(ctx context.Context, in *GetMetadataRequest, opts ...grpc.CallOption) (*GetMetadataResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetMetadataResponse) + err := c.cc.Invoke(ctx, Dapr_GetMetadata_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SetMetadata(ctx context.Context, in *SetMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_SetMetadata_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleGetKeyAlpha1(ctx context.Context, in *SubtleGetKeyRequest, opts ...grpc.CallOption) (*SubtleGetKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleGetKeyResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleGetKeyAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleEncryptAlpha1(ctx context.Context, in *SubtleEncryptRequest, opts ...grpc.CallOption) (*SubtleEncryptResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleEncryptResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleEncryptAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleDecryptAlpha1(ctx context.Context, in *SubtleDecryptRequest, opts ...grpc.CallOption) (*SubtleDecryptResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleDecryptResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleDecryptAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleWrapKeyAlpha1(ctx context.Context, in *SubtleWrapKeyRequest, opts ...grpc.CallOption) (*SubtleWrapKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleWrapKeyResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleWrapKeyAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleUnwrapKeyAlpha1(ctx context.Context, in *SubtleUnwrapKeyRequest, opts ...grpc.CallOption) (*SubtleUnwrapKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleUnwrapKeyResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleUnwrapKeyAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleSignAlpha1(ctx context.Context, in *SubtleSignRequest, opts ...grpc.CallOption) (*SubtleSignResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleSignResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleSignAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) SubtleVerifyAlpha1(ctx context.Context, in *SubtleVerifyRequest, opts ...grpc.CallOption) (*SubtleVerifyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SubtleVerifyResponse) + err := c.cc.Invoke(ctx, Dapr_SubtleVerifyAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) StartWorkflowAlpha1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StartWorkflowResponse) + err := c.cc.Invoke(ctx, Dapr_StartWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) GetWorkflowAlpha1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetWorkflowResponse) + err := c.cc.Invoke(ctx, Dapr_GetWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) PurgeWorkflowAlpha1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_PurgeWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) TerminateWorkflowAlpha1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_TerminateWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) PauseWorkflowAlpha1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_PauseWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) ResumeWorkflowAlpha1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_ResumeWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *daprClient) RaiseEventWorkflowAlpha1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_RaiseEventWorkflowAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) StartWorkflowBeta1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StartWorkflowResponse) + err := c.cc.Invoke(ctx, Dapr_StartWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetWorkflowBeta1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetWorkflowResponse) + err := c.cc.Invoke(ctx, Dapr_GetWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) PurgeWorkflowBeta1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_PurgeWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) TerminateWorkflowBeta1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_TerminateWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) PauseWorkflowBeta1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_PauseWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) ResumeWorkflowBeta1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_ResumeWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) RaiseEventWorkflowBeta1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_RaiseEventWorkflowBeta1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, Dapr_Shutdown_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) ScheduleJobAlpha1(ctx context.Context, in *ScheduleJobRequest, opts ...grpc.CallOption) (*ScheduleJobResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ScheduleJobResponse) + err := c.cc.Invoke(ctx, Dapr_ScheduleJobAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) GetJobAlpha1(ctx context.Context, in *GetJobRequest, opts ...grpc.CallOption) (*GetJobResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetJobResponse) + err := c.cc.Invoke(ctx, Dapr_GetJobAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) DeleteJobAlpha1(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*DeleteJobResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DeleteJobResponse) + err := c.cc.Invoke(ctx, Dapr_DeleteJobAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *daprClient) ConverseAlpha1(ctx context.Context, in *ConversationRequest, opts ...grpc.CallOption) (*ConversationResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ConversationResponse) + err := c.cc.Invoke(ctx, Dapr_ConverseAlpha1_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DaprServer is the server API for Dapr service. +// All implementations must embed UnimplementedDaprServer +// for forward compatibility. +// +// Dapr service provides APIs to user application to access Dapr building blocks. +type DaprServer interface { + // Invokes a method on a remote Dapr app. + // Deprecated: Use proxy mode service invocation instead. + InvokeService(context.Context, *InvokeServiceRequest) (*v1.InvokeResponse, error) + // Gets the state for a specific key. + GetState(context.Context, *GetStateRequest) (*GetStateResponse, error) + // Gets a bulk of state items for a list of keys + GetBulkState(context.Context, *GetBulkStateRequest) (*GetBulkStateResponse, error) + // Saves the state for a specific key. + SaveState(context.Context, *SaveStateRequest) (*emptypb.Empty, error) + // Queries the state. + QueryStateAlpha1(context.Context, *QueryStateRequest) (*QueryStateResponse, error) + // Deletes the state for a specific key. + DeleteState(context.Context, *DeleteStateRequest) (*emptypb.Empty, error) + // Deletes a bulk of state items for a list of keys + DeleteBulkState(context.Context, *DeleteBulkStateRequest) (*emptypb.Empty, error) + // Executes transactions for a specified store + ExecuteStateTransaction(context.Context, *ExecuteStateTransactionRequest) (*emptypb.Empty, error) + // Publishes events to the specific topic. + PublishEvent(context.Context, *PublishEventRequest) (*emptypb.Empty, error) + // Bulk Publishes multiple events to the specified topic. + BulkPublishEventAlpha1(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error) + // SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic + // events from it. + SubscribeTopicEventsAlpha1(grpc.BidiStreamingServer[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1]) error + // Invokes binding data to specific output bindings + InvokeBinding(context.Context, *InvokeBindingRequest) (*InvokeBindingResponse, error) + // Gets secrets from secret stores. + GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error) + // Gets a bulk of secrets + GetBulkSecret(context.Context, *GetBulkSecretRequest) (*GetBulkSecretResponse, error) + // Register an actor timer. + RegisterActorTimer(context.Context, *RegisterActorTimerRequest) (*emptypb.Empty, error) + // Unregister an actor timer. + UnregisterActorTimer(context.Context, *UnregisterActorTimerRequest) (*emptypb.Empty, error) + // Register an actor reminder. + RegisterActorReminder(context.Context, *RegisterActorReminderRequest) (*emptypb.Empty, error) + // Unregister an actor reminder. + UnregisterActorReminder(context.Context, *UnregisterActorReminderRequest) (*emptypb.Empty, error) + // Gets the state for a specific actor. + GetActorState(context.Context, *GetActorStateRequest) (*GetActorStateResponse, error) + // Executes state transactions for a specified actor + ExecuteActorStateTransaction(context.Context, *ExecuteActorStateTransactionRequest) (*emptypb.Empty, error) + // InvokeActor calls a method on an actor. + InvokeActor(context.Context, *InvokeActorRequest) (*InvokeActorResponse, error) + // GetConfiguration gets configuration from configuration store. + GetConfigurationAlpha1(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) + // GetConfiguration gets configuration from configuration store. + GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) + // SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + SubscribeConfigurationAlpha1(*SubscribeConfigurationRequest, grpc.ServerStreamingServer[SubscribeConfigurationResponse]) error + // SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + SubscribeConfiguration(*SubscribeConfigurationRequest, grpc.ServerStreamingServer[SubscribeConfigurationResponse]) error + // UnSubscribeConfiguration unsubscribe the subscription of configuration + UnsubscribeConfigurationAlpha1(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) + // UnSubscribeConfiguration unsubscribe the subscription of configuration + UnsubscribeConfiguration(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) + // TryLockAlpha1 tries to get a lock with an expiry. + TryLockAlpha1(context.Context, *TryLockRequest) (*TryLockResponse, error) + // UnlockAlpha1 unlocks a lock. + UnlockAlpha1(context.Context, *UnlockRequest) (*UnlockResponse, error) + // EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault. + EncryptAlpha1(grpc.BidiStreamingServer[EncryptRequest, EncryptResponse]) error + // DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault. + DecryptAlpha1(grpc.BidiStreamingServer[DecryptRequest, DecryptResponse]) error + // Gets metadata of the sidecar + GetMetadata(context.Context, *GetMetadataRequest) (*GetMetadataResponse, error) + // Sets value in extended metadata of the sidecar + SetMetadata(context.Context, *SetMetadataRequest) (*emptypb.Empty, error) + // SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault. + SubtleGetKeyAlpha1(context.Context, *SubtleGetKeyRequest) (*SubtleGetKeyResponse, error) + // SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault. + SubtleEncryptAlpha1(context.Context, *SubtleEncryptRequest) (*SubtleEncryptResponse, error) + // SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault. + SubtleDecryptAlpha1(context.Context, *SubtleDecryptRequest) (*SubtleDecryptResponse, error) + // SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault. + SubtleWrapKeyAlpha1(context.Context, *SubtleWrapKeyRequest) (*SubtleWrapKeyResponse, error) + // SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault. + SubtleUnwrapKeyAlpha1(context.Context, *SubtleUnwrapKeyRequest) (*SubtleUnwrapKeyResponse, error) + // SubtleSignAlpha1 signs a message using a key stored in the vault. + SubtleSignAlpha1(context.Context, *SubtleSignRequest) (*SubtleSignResponse, error) + // SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault. + SubtleVerifyAlpha1(context.Context, *SubtleVerifyRequest) (*SubtleVerifyResponse, error) + // Deprecated: Do not use. + // Starts a new instance of a workflow + StartWorkflowAlpha1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) + // Deprecated: Do not use. + // Gets details about a started workflow instance + GetWorkflowAlpha1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) + // Deprecated: Do not use. + // Purge Workflow + PurgeWorkflowAlpha1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Terminates a running workflow instance + TerminateWorkflowAlpha1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Pauses a running workflow instance + PauseWorkflowAlpha1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Resumes a paused workflow instance + ResumeWorkflowAlpha1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) + // Deprecated: Do not use. + // Raise an event to a running workflow instance + RaiseEventWorkflowAlpha1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) + // Starts a new instance of a workflow + StartWorkflowBeta1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) + // Gets details about a started workflow instance + GetWorkflowBeta1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) + // Purge Workflow + PurgeWorkflowBeta1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) + // Terminates a running workflow instance + TerminateWorkflowBeta1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) + // Pauses a running workflow instance + PauseWorkflowBeta1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) + // Resumes a paused workflow instance + ResumeWorkflowBeta1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) + // Raise an event to a running workflow instance + RaiseEventWorkflowBeta1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) + // Shutdown the sidecar + Shutdown(context.Context, *ShutdownRequest) (*emptypb.Empty, error) + // Create and schedule a job + ScheduleJobAlpha1(context.Context, *ScheduleJobRequest) (*ScheduleJobResponse, error) + // Gets a scheduled job + GetJobAlpha1(context.Context, *GetJobRequest) (*GetJobResponse, error) + // Delete a job + DeleteJobAlpha1(context.Context, *DeleteJobRequest) (*DeleteJobResponse, error) + // Converse with a LLM service + ConverseAlpha1(context.Context, *ConversationRequest) (*ConversationResponse, error) + mustEmbedUnimplementedDaprServer() +} + +// UnimplementedDaprServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedDaprServer struct{} + +func (UnimplementedDaprServer) InvokeService(context.Context, *InvokeServiceRequest) (*v1.InvokeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InvokeService not implemented") +} +func (UnimplementedDaprServer) GetState(context.Context, *GetStateRequest) (*GetStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetState not implemented") +} +func (UnimplementedDaprServer) GetBulkState(context.Context, *GetBulkStateRequest) (*GetBulkStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBulkState not implemented") +} +func (UnimplementedDaprServer) SaveState(context.Context, *SaveStateRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method SaveState not implemented") +} +func (UnimplementedDaprServer) QueryStateAlpha1(context.Context, *QueryStateRequest) (*QueryStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryStateAlpha1 not implemented") +} +func (UnimplementedDaprServer) DeleteState(context.Context, *DeleteStateRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteState not implemented") +} +func (UnimplementedDaprServer) DeleteBulkState(context.Context, *DeleteBulkStateRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteBulkState not implemented") +} +func (UnimplementedDaprServer) ExecuteStateTransaction(context.Context, *ExecuteStateTransactionRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method ExecuteStateTransaction not implemented") +} +func (UnimplementedDaprServer) PublishEvent(context.Context, *PublishEventRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PublishEvent not implemented") +} +func (UnimplementedDaprServer) BulkPublishEventAlpha1(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BulkPublishEventAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubscribeTopicEventsAlpha1(grpc.BidiStreamingServer[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1]) error { + return status.Errorf(codes.Unimplemented, "method SubscribeTopicEventsAlpha1 not implemented") +} +func (UnimplementedDaprServer) InvokeBinding(context.Context, *InvokeBindingRequest) (*InvokeBindingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InvokeBinding not implemented") +} +func (UnimplementedDaprServer) GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetSecret not implemented") +} +func (UnimplementedDaprServer) GetBulkSecret(context.Context, *GetBulkSecretRequest) (*GetBulkSecretResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBulkSecret not implemented") +} +func (UnimplementedDaprServer) RegisterActorTimer(context.Context, *RegisterActorTimerRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterActorTimer not implemented") +} +func (UnimplementedDaprServer) UnregisterActorTimer(context.Context, *UnregisterActorTimerRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnregisterActorTimer not implemented") +} +func (UnimplementedDaprServer) RegisterActorReminder(context.Context, *RegisterActorReminderRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterActorReminder not implemented") +} +func (UnimplementedDaprServer) UnregisterActorReminder(context.Context, *UnregisterActorReminderRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnregisterActorReminder not implemented") +} +func (UnimplementedDaprServer) GetActorState(context.Context, *GetActorStateRequest) (*GetActorStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetActorState not implemented") +} +func (UnimplementedDaprServer) ExecuteActorStateTransaction(context.Context, *ExecuteActorStateTransactionRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method ExecuteActorStateTransaction not implemented") +} +func (UnimplementedDaprServer) InvokeActor(context.Context, *InvokeActorRequest) (*InvokeActorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InvokeActor not implemented") +} +func (UnimplementedDaprServer) GetConfigurationAlpha1(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetConfigurationAlpha1 not implemented") +} +func (UnimplementedDaprServer) GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetConfiguration not implemented") +} +func (UnimplementedDaprServer) SubscribeConfigurationAlpha1(*SubscribeConfigurationRequest, grpc.ServerStreamingServer[SubscribeConfigurationResponse]) error { + return status.Errorf(codes.Unimplemented, "method SubscribeConfigurationAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubscribeConfiguration(*SubscribeConfigurationRequest, grpc.ServerStreamingServer[SubscribeConfigurationResponse]) error { + return status.Errorf(codes.Unimplemented, "method SubscribeConfiguration not implemented") +} +func (UnimplementedDaprServer) UnsubscribeConfigurationAlpha1(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnsubscribeConfigurationAlpha1 not implemented") +} +func (UnimplementedDaprServer) UnsubscribeConfiguration(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnsubscribeConfiguration not implemented") +} +func (UnimplementedDaprServer) TryLockAlpha1(context.Context, *TryLockRequest) (*TryLockResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TryLockAlpha1 not implemented") +} +func (UnimplementedDaprServer) UnlockAlpha1(context.Context, *UnlockRequest) (*UnlockResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnlockAlpha1 not implemented") +} +func (UnimplementedDaprServer) EncryptAlpha1(grpc.BidiStreamingServer[EncryptRequest, EncryptResponse]) error { + return status.Errorf(codes.Unimplemented, "method EncryptAlpha1 not implemented") +} +func (UnimplementedDaprServer) DecryptAlpha1(grpc.BidiStreamingServer[DecryptRequest, DecryptResponse]) error { + return status.Errorf(codes.Unimplemented, "method DecryptAlpha1 not implemented") +} +func (UnimplementedDaprServer) GetMetadata(context.Context, *GetMetadataRequest) (*GetMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMetadata not implemented") +} +func (UnimplementedDaprServer) SetMetadata(context.Context, *SetMetadataRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetMetadata not implemented") +} +func (UnimplementedDaprServer) SubtleGetKeyAlpha1(context.Context, *SubtleGetKeyRequest) (*SubtleGetKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleGetKeyAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleEncryptAlpha1(context.Context, *SubtleEncryptRequest) (*SubtleEncryptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleEncryptAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleDecryptAlpha1(context.Context, *SubtleDecryptRequest) (*SubtleDecryptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleDecryptAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleWrapKeyAlpha1(context.Context, *SubtleWrapKeyRequest) (*SubtleWrapKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleWrapKeyAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleUnwrapKeyAlpha1(context.Context, *SubtleUnwrapKeyRequest) (*SubtleUnwrapKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleUnwrapKeyAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleSignAlpha1(context.Context, *SubtleSignRequest) (*SubtleSignResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleSignAlpha1 not implemented") +} +func (UnimplementedDaprServer) SubtleVerifyAlpha1(context.Context, *SubtleVerifyRequest) (*SubtleVerifyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SubtleVerifyAlpha1 not implemented") +} +func (UnimplementedDaprServer) StartWorkflowAlpha1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StartWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) GetWorkflowAlpha1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) PurgeWorkflowAlpha1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PurgeWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) TerminateWorkflowAlpha1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method TerminateWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) PauseWorkflowAlpha1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PauseWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) ResumeWorkflowAlpha1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResumeWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) RaiseEventWorkflowAlpha1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method RaiseEventWorkflowAlpha1 not implemented") +} +func (UnimplementedDaprServer) StartWorkflowBeta1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StartWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) GetWorkflowBeta1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) PurgeWorkflowBeta1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PurgeWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) TerminateWorkflowBeta1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method TerminateWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) PauseWorkflowBeta1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PauseWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) ResumeWorkflowBeta1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResumeWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) RaiseEventWorkflowBeta1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method RaiseEventWorkflowBeta1 not implemented") +} +func (UnimplementedDaprServer) Shutdown(context.Context, *ShutdownRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented") +} +func (UnimplementedDaprServer) ScheduleJobAlpha1(context.Context, *ScheduleJobRequest) (*ScheduleJobResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ScheduleJobAlpha1 not implemented") +} +func (UnimplementedDaprServer) GetJobAlpha1(context.Context, *GetJobRequest) (*GetJobResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetJobAlpha1 not implemented") +} +func (UnimplementedDaprServer) DeleteJobAlpha1(context.Context, *DeleteJobRequest) (*DeleteJobResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteJobAlpha1 not implemented") +} +func (UnimplementedDaprServer) ConverseAlpha1(context.Context, *ConversationRequest) (*ConversationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConverseAlpha1 not implemented") +} +func (UnimplementedDaprServer) mustEmbedUnimplementedDaprServer() {} +func (UnimplementedDaprServer) testEmbeddedByValue() {} + +// UnsafeDaprServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to DaprServer will +// result in compilation errors. +type UnsafeDaprServer interface { + mustEmbedUnimplementedDaprServer() +} + +func RegisterDaprServer(s grpc.ServiceRegistrar, srv DaprServer) { + // If the following call pancis, it indicates UnimplementedDaprServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&Dapr_ServiceDesc, srv) +} + +func _Dapr_InvokeService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InvokeServiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).InvokeService(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_InvokeService_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).InvokeService(ctx, req.(*InvokeServiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetState(ctx, req.(*GetStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetBulkState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBulkStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetBulkState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetBulkState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetBulkState(ctx, req.(*GetBulkStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SaveState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SaveStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SaveState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SaveState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SaveState(ctx, req.(*SaveStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_QueryStateAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).QueryStateAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_QueryStateAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).QueryStateAlpha1(ctx, req.(*QueryStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_DeleteState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).DeleteState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_DeleteState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).DeleteState(ctx, req.(*DeleteStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_DeleteBulkState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteBulkStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).DeleteBulkState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_DeleteBulkState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).DeleteBulkState(ctx, req.(*DeleteBulkStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ExecuteStateTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExecuteStateTransactionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ExecuteStateTransaction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ExecuteStateTransaction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ExecuteStateTransaction(ctx, req.(*ExecuteStateTransactionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_PublishEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PublishEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).PublishEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_PublishEvent_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).PublishEvent(ctx, req.(*PublishEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_BulkPublishEventAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BulkPublishRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).BulkPublishEventAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_BulkPublishEventAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).BulkPublishEventAlpha1(ctx, req.(*BulkPublishRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubscribeTopicEventsAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(DaprServer).SubscribeTopicEventsAlpha1(&grpc.GenericServerStream[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeTopicEventsAlpha1Server = grpc.BidiStreamingServer[SubscribeTopicEventsRequestAlpha1, SubscribeTopicEventsResponseAlpha1] + +func _Dapr_InvokeBinding_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InvokeBindingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).InvokeBinding(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_InvokeBinding_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).InvokeBinding(ctx, req.(*InvokeBindingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetSecret(ctx, req.(*GetSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetBulkSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBulkSecretRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetBulkSecret(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetBulkSecret_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetBulkSecret(ctx, req.(*GetBulkSecretRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_RegisterActorTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RegisterActorTimerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).RegisterActorTimer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_RegisterActorTimer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).RegisterActorTimer(ctx, req.(*RegisterActorTimerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_UnregisterActorTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnregisterActorTimerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).UnregisterActorTimer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_UnregisterActorTimer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).UnregisterActorTimer(ctx, req.(*UnregisterActorTimerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_RegisterActorReminder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RegisterActorReminderRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).RegisterActorReminder(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_RegisterActorReminder_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).RegisterActorReminder(ctx, req.(*RegisterActorReminderRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_UnregisterActorReminder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnregisterActorReminderRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).UnregisterActorReminder(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_UnregisterActorReminder_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).UnregisterActorReminder(ctx, req.(*UnregisterActorReminderRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetActorState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActorStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetActorState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetActorState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetActorState(ctx, req.(*GetActorStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ExecuteActorStateTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExecuteActorStateTransactionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ExecuteActorStateTransaction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ExecuteActorStateTransaction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ExecuteActorStateTransaction(ctx, req.(*ExecuteActorStateTransactionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_InvokeActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InvokeActorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).InvokeActor(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_InvokeActor_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).InvokeActor(ctx, req.(*InvokeActorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetConfigurationAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetConfigurationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetConfigurationAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetConfigurationAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetConfigurationAlpha1(ctx, req.(*GetConfigurationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetConfigurationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetConfiguration(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetConfiguration_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetConfiguration(ctx, req.(*GetConfigurationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubscribeConfigurationAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeConfigurationRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(DaprServer).SubscribeConfigurationAlpha1(m, &grpc.GenericServerStream[SubscribeConfigurationRequest, SubscribeConfigurationResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeConfigurationAlpha1Server = grpc.ServerStreamingServer[SubscribeConfigurationResponse] + +func _Dapr_SubscribeConfiguration_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeConfigurationRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(DaprServer).SubscribeConfiguration(m, &grpc.GenericServerStream[SubscribeConfigurationRequest, SubscribeConfigurationResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_SubscribeConfigurationServer = grpc.ServerStreamingServer[SubscribeConfigurationResponse] + +func _Dapr_UnsubscribeConfigurationAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnsubscribeConfigurationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).UnsubscribeConfigurationAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_UnsubscribeConfigurationAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).UnsubscribeConfigurationAlpha1(ctx, req.(*UnsubscribeConfigurationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_UnsubscribeConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnsubscribeConfigurationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).UnsubscribeConfiguration(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_UnsubscribeConfiguration_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).UnsubscribeConfiguration(ctx, req.(*UnsubscribeConfigurationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_TryLockAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TryLockRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).TryLockAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_TryLockAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).TryLockAlpha1(ctx, req.(*TryLockRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_UnlockAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnlockRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).UnlockAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_UnlockAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).UnlockAlpha1(ctx, req.(*UnlockRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_EncryptAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(DaprServer).EncryptAlpha1(&grpc.GenericServerStream[EncryptRequest, EncryptResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_EncryptAlpha1Server = grpc.BidiStreamingServer[EncryptRequest, EncryptResponse] + +func _Dapr_DecryptAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(DaprServer).DecryptAlpha1(&grpc.GenericServerStream[DecryptRequest, DecryptResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dapr_DecryptAlpha1Server = grpc.BidiStreamingServer[DecryptRequest, DecryptResponse] + +func _Dapr_GetMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMetadataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetMetadata_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetMetadata(ctx, req.(*GetMetadataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SetMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetMetadataRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SetMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SetMetadata_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SetMetadata(ctx, req.(*SetMetadataRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleGetKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleGetKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleGetKeyAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleGetKeyAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleGetKeyAlpha1(ctx, req.(*SubtleGetKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleEncryptAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleEncryptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleEncryptAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleEncryptAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleEncryptAlpha1(ctx, req.(*SubtleEncryptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleDecryptAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleDecryptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleDecryptAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleDecryptAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleDecryptAlpha1(ctx, req.(*SubtleDecryptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleWrapKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleWrapKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleWrapKeyAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleWrapKeyAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleWrapKeyAlpha1(ctx, req.(*SubtleWrapKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleUnwrapKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleUnwrapKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleUnwrapKeyAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleUnwrapKeyAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleUnwrapKeyAlpha1(ctx, req.(*SubtleUnwrapKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleSignAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleSignRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleSignAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleSignAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleSignAlpha1(ctx, req.(*SubtleSignRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_SubtleVerifyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SubtleVerifyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).SubtleVerifyAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_SubtleVerifyAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).SubtleVerifyAlpha1(ctx, req.(*SubtleVerifyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_StartWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StartWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).StartWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_StartWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).StartWorkflowAlpha1(ctx, req.(*StartWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetWorkflowAlpha1(ctx, req.(*GetWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_PurgeWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PurgeWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).PurgeWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_PurgeWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).PurgeWorkflowAlpha1(ctx, req.(*PurgeWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_TerminateWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TerminateWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).TerminateWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_TerminateWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).TerminateWorkflowAlpha1(ctx, req.(*TerminateWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_PauseWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PauseWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).PauseWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_PauseWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).PauseWorkflowAlpha1(ctx, req.(*PauseWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ResumeWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResumeWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ResumeWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ResumeWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ResumeWorkflowAlpha1(ctx, req.(*ResumeWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_RaiseEventWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RaiseEventWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).RaiseEventWorkflowAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_RaiseEventWorkflowAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).RaiseEventWorkflowAlpha1(ctx, req.(*RaiseEventWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_StartWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StartWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).StartWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_StartWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).StartWorkflowBeta1(ctx, req.(*StartWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetWorkflowBeta1(ctx, req.(*GetWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_PurgeWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PurgeWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).PurgeWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_PurgeWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).PurgeWorkflowBeta1(ctx, req.(*PurgeWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_TerminateWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TerminateWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).TerminateWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_TerminateWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).TerminateWorkflowBeta1(ctx, req.(*TerminateWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_PauseWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PauseWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).PauseWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_PauseWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).PauseWorkflowBeta1(ctx, req.(*PauseWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ResumeWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResumeWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ResumeWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ResumeWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ResumeWorkflowBeta1(ctx, req.(*ResumeWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_RaiseEventWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RaiseEventWorkflowRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).RaiseEventWorkflowBeta1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_RaiseEventWorkflowBeta1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).RaiseEventWorkflowBeta1(ctx, req.(*RaiseEventWorkflowRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ShutdownRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).Shutdown(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_Shutdown_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).Shutdown(ctx, req.(*ShutdownRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ScheduleJobAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ScheduleJobRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ScheduleJobAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ScheduleJobAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ScheduleJobAlpha1(ctx, req.(*ScheduleJobRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_GetJobAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetJobRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).GetJobAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_GetJobAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).GetJobAlpha1(ctx, req.(*GetJobRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_DeleteJobAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteJobRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).DeleteJobAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_DeleteJobAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).DeleteJobAlpha1(ctx, req.(*DeleteJobRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Dapr_ConverseAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConversationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DaprServer).ConverseAlpha1(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Dapr_ConverseAlpha1_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DaprServer).ConverseAlpha1(ctx, req.(*ConversationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Dapr_ServiceDesc is the grpc.ServiceDesc for Dapr service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Dapr_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "dapr.proto.runtime.v1.Dapr", + HandlerType: (*DaprServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "InvokeService", + Handler: _Dapr_InvokeService_Handler, + }, + { + MethodName: "GetState", + Handler: _Dapr_GetState_Handler, + }, + { + MethodName: "GetBulkState", + Handler: _Dapr_GetBulkState_Handler, + }, + { + MethodName: "SaveState", + Handler: _Dapr_SaveState_Handler, + }, + { + MethodName: "QueryStateAlpha1", + Handler: _Dapr_QueryStateAlpha1_Handler, + }, + { + MethodName: "DeleteState", + Handler: _Dapr_DeleteState_Handler, + }, + { + MethodName: "DeleteBulkState", + Handler: _Dapr_DeleteBulkState_Handler, + }, + { + MethodName: "ExecuteStateTransaction", + Handler: _Dapr_ExecuteStateTransaction_Handler, + }, + { + MethodName: "PublishEvent", + Handler: _Dapr_PublishEvent_Handler, + }, + { + MethodName: "BulkPublishEventAlpha1", + Handler: _Dapr_BulkPublishEventAlpha1_Handler, + }, + { + MethodName: "InvokeBinding", + Handler: _Dapr_InvokeBinding_Handler, + }, + { + MethodName: "GetSecret", + Handler: _Dapr_GetSecret_Handler, + }, + { + MethodName: "GetBulkSecret", + Handler: _Dapr_GetBulkSecret_Handler, + }, + { + MethodName: "RegisterActorTimer", + Handler: _Dapr_RegisterActorTimer_Handler, + }, + { + MethodName: "UnregisterActorTimer", + Handler: _Dapr_UnregisterActorTimer_Handler, + }, + { + MethodName: "RegisterActorReminder", + Handler: _Dapr_RegisterActorReminder_Handler, + }, + { + MethodName: "UnregisterActorReminder", + Handler: _Dapr_UnregisterActorReminder_Handler, + }, + { + MethodName: "GetActorState", + Handler: _Dapr_GetActorState_Handler, + }, + { + MethodName: "ExecuteActorStateTransaction", + Handler: _Dapr_ExecuteActorStateTransaction_Handler, + }, + { + MethodName: "InvokeActor", + Handler: _Dapr_InvokeActor_Handler, + }, + { + MethodName: "GetConfigurationAlpha1", + Handler: _Dapr_GetConfigurationAlpha1_Handler, + }, + { + MethodName: "GetConfiguration", + Handler: _Dapr_GetConfiguration_Handler, + }, + { + MethodName: "UnsubscribeConfigurationAlpha1", + Handler: _Dapr_UnsubscribeConfigurationAlpha1_Handler, + }, + { + MethodName: "UnsubscribeConfiguration", + Handler: _Dapr_UnsubscribeConfiguration_Handler, + }, + { + MethodName: "TryLockAlpha1", + Handler: _Dapr_TryLockAlpha1_Handler, + }, + { + MethodName: "UnlockAlpha1", + Handler: _Dapr_UnlockAlpha1_Handler, + }, + { + MethodName: "GetMetadata", + Handler: _Dapr_GetMetadata_Handler, + }, + { + MethodName: "SetMetadata", + Handler: _Dapr_SetMetadata_Handler, + }, + { + MethodName: "SubtleGetKeyAlpha1", + Handler: _Dapr_SubtleGetKeyAlpha1_Handler, + }, + { + MethodName: "SubtleEncryptAlpha1", + Handler: _Dapr_SubtleEncryptAlpha1_Handler, + }, + { + MethodName: "SubtleDecryptAlpha1", + Handler: _Dapr_SubtleDecryptAlpha1_Handler, + }, + { + MethodName: "SubtleWrapKeyAlpha1", + Handler: _Dapr_SubtleWrapKeyAlpha1_Handler, + }, + { + MethodName: "SubtleUnwrapKeyAlpha1", + Handler: _Dapr_SubtleUnwrapKeyAlpha1_Handler, + }, + { + MethodName: "SubtleSignAlpha1", + Handler: _Dapr_SubtleSignAlpha1_Handler, + }, + { + MethodName: "SubtleVerifyAlpha1", + Handler: _Dapr_SubtleVerifyAlpha1_Handler, + }, + { + MethodName: "StartWorkflowAlpha1", + Handler: _Dapr_StartWorkflowAlpha1_Handler, + }, + { + MethodName: "GetWorkflowAlpha1", + Handler: _Dapr_GetWorkflowAlpha1_Handler, + }, + { + MethodName: "PurgeWorkflowAlpha1", + Handler: _Dapr_PurgeWorkflowAlpha1_Handler, + }, + { + MethodName: "TerminateWorkflowAlpha1", + Handler: _Dapr_TerminateWorkflowAlpha1_Handler, + }, + { + MethodName: "PauseWorkflowAlpha1", + Handler: _Dapr_PauseWorkflowAlpha1_Handler, + }, + { + MethodName: "ResumeWorkflowAlpha1", + Handler: _Dapr_ResumeWorkflowAlpha1_Handler, + }, + { + MethodName: "RaiseEventWorkflowAlpha1", + Handler: _Dapr_RaiseEventWorkflowAlpha1_Handler, + }, + { + MethodName: "StartWorkflowBeta1", + Handler: _Dapr_StartWorkflowBeta1_Handler, + }, + { + MethodName: "GetWorkflowBeta1", + Handler: _Dapr_GetWorkflowBeta1_Handler, + }, + { + MethodName: "PurgeWorkflowBeta1", + Handler: _Dapr_PurgeWorkflowBeta1_Handler, + }, + { + MethodName: "TerminateWorkflowBeta1", + Handler: _Dapr_TerminateWorkflowBeta1_Handler, + }, + { + MethodName: "PauseWorkflowBeta1", + Handler: _Dapr_PauseWorkflowBeta1_Handler, + }, + { + MethodName: "ResumeWorkflowBeta1", + Handler: _Dapr_ResumeWorkflowBeta1_Handler, + }, + { + MethodName: "RaiseEventWorkflowBeta1", + Handler: _Dapr_RaiseEventWorkflowBeta1_Handler, + }, + { + MethodName: "Shutdown", + Handler: _Dapr_Shutdown_Handler, + }, + { + MethodName: "ScheduleJobAlpha1", + Handler: _Dapr_ScheduleJobAlpha1_Handler, + }, + { + MethodName: "GetJobAlpha1", + Handler: _Dapr_GetJobAlpha1_Handler, + }, + { + MethodName: "DeleteJobAlpha1", + Handler: _Dapr_DeleteJobAlpha1_Handler, + }, + { + MethodName: "ConverseAlpha1", + Handler: _Dapr_ConverseAlpha1_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "SubscribeTopicEventsAlpha1", + Handler: _Dapr_SubscribeTopicEventsAlpha1_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "SubscribeConfigurationAlpha1", + Handler: _Dapr_SubscribeConfigurationAlpha1_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribeConfiguration", + Handler: _Dapr_SubscribeConfiguration_Handler, + ServerStreams: true, + }, + { + StreamName: "EncryptAlpha1", + Handler: _Dapr_EncryptAlpha1_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "DecryptAlpha1", + Handler: _Dapr_DecryptAlpha1_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "dapr/proto/runtime/v1/dapr.proto", +} diff --git a/service/grpc/binding.go b/service/grpc/binding.go index 288021bc..7d9949b0 100644 --- a/service/grpc/binding.go +++ b/service/grpc/binding.go @@ -20,7 +20,7 @@ import ( "google.golang.org/protobuf/types/known/emptypb" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) diff --git a/service/grpc/binding_test.go b/service/grpc/binding_test.go index 765cb973..76436170 100644 --- a/service/grpc/binding_test.go +++ b/service/grpc/binding_test.go @@ -23,7 +23,7 @@ import ( "github.com/stretchr/testify/assert" "google.golang.org/protobuf/types/known/emptypb" - "github.com/dapr/dapr/pkg/proto/runtime/v1" + runtime "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) diff --git a/service/grpc/health_check.go b/service/grpc/health_check.go index d835b58d..69ff511c 100644 --- a/service/grpc/health_check.go +++ b/service/grpc/health_check.go @@ -17,7 +17,7 @@ import ( "context" "errors" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" "google.golang.org/protobuf/types/known/emptypb" diff --git a/service/grpc/invoke.go b/service/grpc/invoke.go index 0ed8bee1..6dfb0e36 100644 --- a/service/grpc/invoke.go +++ b/service/grpc/invoke.go @@ -21,7 +21,7 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/protobuf/types/known/anypb" - cpb "github.com/dapr/dapr/pkg/proto/common/v1" + cpb "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" cc "github.com/dapr/go-sdk/service/common" ) diff --git a/service/grpc/invoke_test.go b/service/grpc/invoke_test.go index bf980b73..68d5f66d 100644 --- a/service/grpc/invoke_test.go +++ b/service/grpc/invoke_test.go @@ -25,7 +25,7 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/protobuf/types/known/anypb" - "github.com/dapr/dapr/pkg/proto/common/v1" + common "github.com/dapr/go-sdk/internal/proto/dapr/proto/common/v1" cc "github.com/dapr/go-sdk/service/common" ) diff --git a/service/grpc/scheduling.go b/service/grpc/scheduling.go index 4bbd1b6d..36acdda7 100644 --- a/service/grpc/scheduling.go +++ b/service/grpc/scheduling.go @@ -6,7 +6,7 @@ import ( "fmt" "strings" - runtimepb "github.com/dapr/dapr/pkg/proto/runtime/v1" + runtimepb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" ) diff --git a/service/grpc/service.go b/service/grpc/service.go index 90eedde4..7598602b 100644 --- a/service/grpc/service.go +++ b/service/grpc/service.go @@ -22,9 +22,9 @@ import ( "google.golang.org/grpc" - pb "github.com/dapr/dapr/pkg/proto/runtime/v1" "github.com/dapr/go-sdk/actor" "github.com/dapr/go-sdk/actor/config" + pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" "github.com/dapr/go-sdk/service/internal" ) @@ -79,6 +79,7 @@ func newService(lis net.Listener, grpcServer *grpc.Server, opts ...grpc.ServerOp type Server struct { pb.UnimplementedAppCallbackServer pb.UnimplementedAppCallbackHealthCheckServer + pb.UnimplementedAppCallbackAlphaServer listener net.Listener invokeHandlers map[string]common.ServiceInvocationHandler topicRegistrar internal.TopicRegistrar diff --git a/service/grpc/topic.go b/service/grpc/topic.go index b3ef4dcc..647f245b 100644 --- a/service/grpc/topic.go +++ b/service/grpc/topic.go @@ -24,7 +24,7 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/protobuf/types/known/emptypb" - runtimev1pb "github.com/dapr/dapr/pkg/proto/runtime/v1" + runtimev1pb "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" "github.com/dapr/go-sdk/service/internal" ) diff --git a/service/grpc/topic_test.go b/service/grpc/topic_test.go index fb352585..257183a8 100644 --- a/service/grpc/topic_test.go +++ b/service/grpc/topic_test.go @@ -24,7 +24,7 @@ import ( "github.com/stretchr/testify/assert" "google.golang.org/protobuf/types/known/emptypb" - "github.com/dapr/dapr/pkg/proto/runtime/v1" + runtime "github.com/dapr/go-sdk/internal/proto/dapr/proto/runtime/v1" "github.com/dapr/go-sdk/service/common" )