diff --git a/scripts/fetch-proto.sh b/scripts/fetch-proto.sh index 10bfffc3..91aa8ba7 100755 --- a/scripts/fetch-proto.sh +++ b/scripts/fetch-proto.sh @@ -78,10 +78,15 @@ generateGrpc() { # npm install grpc_tools_node_protoc_ts --save-dev PROTOC_GEN_TS_PATH="${PATH_ROOT}/node_modules/.bin/protoc-gen-ts" PROTOC_GEN_GRPC_PATH="${PATH_ROOT}/node_modules/.bin/grpc_tools_node_protoc_plugin" + # Prefer the grpc-tools bundled protoc for JS generation support on newer protoc versions + PROTOC_BIN="${PATH_ROOT}/node_modules/.bin/grpc_tools_node_protoc" + if [ ! -x "$PROTOC_BIN" ]; then + PROTOC_BIN="protoc" + fi # Note: we specify --proto_path to show where we should start searching from. If we use import it will start from this path # this is why PATH_PROTO != PATH_PROTO_DAPR; PATH_PROTO_DAPR is where we save our proto files while the other is the namespace - protoc \ + "$PROTOC_BIN" \ --proto_path="${PATH_PROTO}" \ --plugin="protoc-gen-ts=${PROTOC_GEN_TS_PATH}" \ --plugin=protoc-gen-grpc=${PROTOC_GEN_GRPC_PATH} \ @@ -131,6 +136,8 @@ downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAM downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/internals/v1/apiversion.proto" "$PATH_ROOT/src/proto/dapr/proto/internals/v1/apiversion.proto" downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/internals/v1/service_invocation.proto" "$PATH_ROOT/src/proto/dapr/proto/internals/v1/service_invocation.proto" downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/internals/v1/status.proto" "$PATH_ROOT/src/proto/dapr/proto/internals/v1/status.proto" +# Missing import used by service_invocation.proto +downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/internals/v1/reminders.proto" "$PATH_ROOT/src/proto/dapr/proto/internals/v1/reminders.proto" downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/operator/v1/operator.proto" "$PATH_ROOT/src/proto/dapr/proto/operator/v1/operator.proto" downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/placement/v1/placement.proto" "$PATH_ROOT/src/proto/dapr/proto/placement/v1/placement.proto" downloadFile "https://raw.githubusercontent.com/$ORG_NAME/$REPO_NAME/$BRANCH_NAME/dapr/proto/runtime/v1/appcallback.proto" "$PATH_ROOT/src/proto/dapr/proto/runtime/v1/appcallback.proto" @@ -147,6 +154,8 @@ echo "" echo "Compiling gRPC files" generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/common/v1/common.proto" generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/internals/v1/apiversion.proto" +# Also generate code for reminders to satisfy imports +generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/internals/v1/reminders.proto" generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/internals/v1/service_invocation.proto" generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/internals/v1/status.proto" generateGrpc "$PATH_ROOT/src/proto" "dapr/proto/operator/v1/operator.proto" diff --git a/src/proto/dapr/proto/common/v1/common.proto b/src/proto/dapr/proto/common/v1/common.proto index 1e63b885..776ae616 100644 --- a/src/proto/dapr/proto/common/v1/common.proto +++ b/src/proto/dapr/proto/common/v1/common.proto @@ -16,6 +16,7 @@ syntax = "proto3"; package dapr.proto.common.v1; import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; option csharp_namespace = "Dapr.Client.Autogen.Grpc.v1"; option java_outer_classname = "CommonProtos"; @@ -24,10 +25,10 @@ option go_package = "github.com/dapr/dapr/pkg/proto/common/v1;common"; // 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 -// +// `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. message HTTPExtension { // Type of HTTP 1.1 Methods @@ -158,3 +159,26 @@ message ConfigurationItem { // the metadata which will be passed to/from configuration store component. map metadata = 3; } + +// JobFailurePolicy defines the policy to apply when a job fails to trigger. +message JobFailurePolicy { + // policy is the policy to apply when a job fails to trigger. + oneof policy { + JobFailurePolicyDrop drop = 1; + JobFailurePolicyConstant constant = 2; + } +} + +// JobFailurePolicyDrop is a policy which drops the job tick when the job fails to trigger. +message JobFailurePolicyDrop {} + +// JobFailurePolicyConstant is a policy which retries the job at a consistent interval when the job fails to trigger. +message JobFailurePolicyConstant { + // interval is the constant delay to wait before retrying the job. + google.protobuf.Duration interval = 1; + + // max_retries is the optional maximum number of retries to attempt before giving up. + // If unset, the Job will be retried indefinitely. + optional uint32 max_retries = 2; +} + diff --git a/src/proto/dapr/proto/common/v1/common_pb.d.ts b/src/proto/dapr/proto/common/v1/common_pb.d.ts index ddc0ae88..dc01147f 100644 --- a/src/proto/dapr/proto/common/v1/common_pb.d.ts +++ b/src/proto/dapr/proto/common/v1/common_pb.d.ts @@ -6,6 +6,7 @@ import * as jspb from "google-protobuf"; import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb"; +import * as google_protobuf_duration_pb from "google-protobuf/google/protobuf/duration_pb"; export class HTTPExtension extends jspb.Message { getVerb(): HTTPExtension.Verb; @@ -255,3 +256,87 @@ export namespace ConfigurationItem { metadataMap: Array<[string, string]>, } } + +export class JobFailurePolicy extends jspb.Message { + + hasDrop(): boolean; + clearDrop(): void; + getDrop(): JobFailurePolicyDrop | undefined; + setDrop(value?: JobFailurePolicyDrop): JobFailurePolicy; + + hasConstant(): boolean; + clearConstant(): void; + getConstant(): JobFailurePolicyConstant | undefined; + setConstant(value?: JobFailurePolicyConstant): JobFailurePolicy; + + getPolicyCase(): JobFailurePolicy.PolicyCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): JobFailurePolicy.AsObject; + static toObject(includeInstance: boolean, msg: JobFailurePolicy): JobFailurePolicy.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: JobFailurePolicy, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): JobFailurePolicy; + static deserializeBinaryFromReader(message: JobFailurePolicy, reader: jspb.BinaryReader): JobFailurePolicy; +} + +export namespace JobFailurePolicy { + export type AsObject = { + drop?: JobFailurePolicyDrop.AsObject, + constant?: JobFailurePolicyConstant.AsObject, + } + + export enum PolicyCase { + POLICY_NOT_SET = 0, + DROP = 1, + CONSTANT = 2, + } + +} + +export class JobFailurePolicyDrop extends jspb.Message { + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): JobFailurePolicyDrop.AsObject; + static toObject(includeInstance: boolean, msg: JobFailurePolicyDrop): JobFailurePolicyDrop.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: JobFailurePolicyDrop, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): JobFailurePolicyDrop; + static deserializeBinaryFromReader(message: JobFailurePolicyDrop, reader: jspb.BinaryReader): JobFailurePolicyDrop; +} + +export namespace JobFailurePolicyDrop { + export type AsObject = { + } +} + +export class JobFailurePolicyConstant extends jspb.Message { + + hasInterval(): boolean; + clearInterval(): void; + getInterval(): google_protobuf_duration_pb.Duration | undefined; + setInterval(value?: google_protobuf_duration_pb.Duration): JobFailurePolicyConstant; + + hasMaxRetries(): boolean; + clearMaxRetries(): void; + getMaxRetries(): number | undefined; + setMaxRetries(value: number): JobFailurePolicyConstant; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): JobFailurePolicyConstant.AsObject; + static toObject(includeInstance: boolean, msg: JobFailurePolicyConstant): JobFailurePolicyConstant.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: JobFailurePolicyConstant, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): JobFailurePolicyConstant; + static deserializeBinaryFromReader(message: JobFailurePolicyConstant, reader: jspb.BinaryReader): JobFailurePolicyConstant; +} + +export namespace JobFailurePolicyConstant { + export type AsObject = { + interval?: google_protobuf_duration_pb.Duration.AsObject, + maxRetries?: number, + } +} diff --git a/src/proto/dapr/proto/common/v1/common_pb.js b/src/proto/dapr/proto/common/v1/common_pb.js index d6c232b1..d1a4a35b 100644 --- a/src/proto/dapr/proto/common/v1/common_pb.js +++ b/src/proto/dapr/proto/common/v1/common_pb.js @@ -13,22 +13,28 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); goog.object.extend(proto, google_protobuf_any_pb); +var google_protobuf_duration_pb = require('google-protobuf/google/protobuf/duration_pb.js'); +goog.object.extend(proto, google_protobuf_duration_pb); goog.exportSymbol('proto.dapr.proto.common.v1.ConfigurationItem', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.Etag', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.HTTPExtension', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.HTTPExtension.Verb', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.InvokeRequest', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.InvokeResponse', null, global); +goog.exportSymbol('proto.dapr.proto.common.v1.JobFailurePolicy', null, global); +goog.exportSymbol('proto.dapr.proto.common.v1.JobFailurePolicy.PolicyCase', null, global); +goog.exportSymbol('proto.dapr.proto.common.v1.JobFailurePolicyConstant', null, global); +goog.exportSymbol('proto.dapr.proto.common.v1.JobFailurePolicyDrop', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.StateItem', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.StateOptions', null, global); goog.exportSymbol('proto.dapr.proto.common.v1.StateOptions.StateConcurrency', null, global); @@ -202,6 +208,69 @@ if (goog.DEBUG && !COMPILED) { */ proto.dapr.proto.common.v1.ConfigurationItem.displayName = 'proto.dapr.proto.common.v1.ConfigurationItem'; } +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.common.v1.JobFailurePolicy = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.dapr.proto.common.v1.JobFailurePolicy.oneofGroups_); +}; +goog.inherits(proto.dapr.proto.common.v1.JobFailurePolicy, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.common.v1.JobFailurePolicy.displayName = 'proto.dapr.proto.common.v1.JobFailurePolicy'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.common.v1.JobFailurePolicyDrop, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.common.v1.JobFailurePolicyDrop.displayName = 'proto.dapr.proto.common.v1.JobFailurePolicyDrop'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.common.v1.JobFailurePolicyConstant, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.common.v1.JobFailurePolicyConstant.displayName = 'proto.dapr.proto.common.v1.JobFailurePolicyConstant'; +} @@ -1284,8 +1353,7 @@ proto.dapr.proto.common.v1.StateItem.prototype.getMetadataMap = function(opt_noL */ proto.dapr.proto.common.v1.StateItem.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; /** @@ -1823,7 +1891,534 @@ proto.dapr.proto.common.v1.ConfigurationItem.prototype.getMetadataMap = function */ proto.dapr.proto.common.v1.ConfigurationItem.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; + return this;}; + + + +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.dapr.proto.common.v1.JobFailurePolicy.oneofGroups_ = [[1,2]]; + +/** + * @enum {number} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.PolicyCase = { + POLICY_NOT_SET: 0, + DROP: 1, + CONSTANT: 2 +}; + +/** + * @return {proto.dapr.proto.common.v1.JobFailurePolicy.PolicyCase} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.getPolicyCase = function() { + return /** @type {proto.dapr.proto.common.v1.JobFailurePolicy.PolicyCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.common.v1.JobFailurePolicy.oneofGroups_[0])); +}; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.common.v1.JobFailurePolicy.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.common.v1.JobFailurePolicy} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicy.toObject = function(includeInstance, msg) { + var f, obj = { + drop: (f = msg.getDrop()) && proto.dapr.proto.common.v1.JobFailurePolicyDrop.toObject(includeInstance, f), + constant: (f = msg.getConstant()) && proto.dapr.proto.common.v1.JobFailurePolicyConstant.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.common.v1.JobFailurePolicy; + return proto.dapr.proto.common.v1.JobFailurePolicy.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicy} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.common.v1.JobFailurePolicyDrop; + reader.readMessage(value,proto.dapr.proto.common.v1.JobFailurePolicyDrop.deserializeBinaryFromReader); + msg.setDrop(value); + break; + case 2: + var value = new proto.dapr.proto.common.v1.JobFailurePolicyConstant; + reader.readMessage(value,proto.dapr.proto.common.v1.JobFailurePolicyConstant.deserializeBinaryFromReader); + msg.setConstant(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.common.v1.JobFailurePolicy.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicy} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicy.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDrop(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.dapr.proto.common.v1.JobFailurePolicyDrop.serializeBinaryToWriter + ); + } + f = message.getConstant(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.dapr.proto.common.v1.JobFailurePolicyConstant.serializeBinaryToWriter + ); + } +}; + + +/** + * optional JobFailurePolicyDrop drop = 1; + * @return {?proto.dapr.proto.common.v1.JobFailurePolicyDrop} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.getDrop = function() { + return /** @type{?proto.dapr.proto.common.v1.JobFailurePolicyDrop} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.common.v1.JobFailurePolicyDrop, 1)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.JobFailurePolicyDrop|undefined} value + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} returns this +*/ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.setDrop = function(value) { + return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.common.v1.JobFailurePolicy.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} returns this + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.clearDrop = function() { + return this.setDrop(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.hasDrop = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional JobFailurePolicyConstant constant = 2; + * @return {?proto.dapr.proto.common.v1.JobFailurePolicyConstant} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.getConstant = function() { + return /** @type{?proto.dapr.proto.common.v1.JobFailurePolicyConstant} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.common.v1.JobFailurePolicyConstant, 2)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.JobFailurePolicyConstant|undefined} value + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} returns this +*/ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.setConstant = function(value) { + return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.common.v1.JobFailurePolicy.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicy} returns this + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.clearConstant = function() { + return this.setConstant(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.common.v1.JobFailurePolicy.prototype.hasConstant = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.common.v1.JobFailurePolicyDrop.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyDrop} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyDrop} + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.common.v1.JobFailurePolicyDrop; + return proto.dapr.proto.common.v1.JobFailurePolicyDrop.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyDrop} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyDrop} + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.common.v1.JobFailurePolicyDrop.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyDrop} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicyDrop.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.common.v1.JobFailurePolicyConstant.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.toObject = function(includeInstance, msg) { + var f, obj = { + interval: (f = msg.getInterval()) && google_protobuf_duration_pb.Duration.toObject(includeInstance, f), + maxRetries: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.common.v1.JobFailurePolicyConstant; + return proto.dapr.proto.common.v1.JobFailurePolicyConstant.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new google_protobuf_duration_pb.Duration; + reader.readMessage(value,google_protobuf_duration_pb.Duration.deserializeBinaryFromReader); + msg.setInterval(value); + break; + case 2: + var value = /** @type {number} */ (reader.readUint32()); + msg.setMaxRetries(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.common.v1.JobFailurePolicyConstant.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getInterval(); + if (f != null) { + writer.writeMessage( + 1, + f, + google_protobuf_duration_pb.Duration.serializeBinaryToWriter + ); + } + f = /** @type {number} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeUint32( + 2, + f + ); + } +}; + + +/** + * optional google.protobuf.Duration interval = 1; + * @return {?proto.google.protobuf.Duration} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.getInterval = function() { + return /** @type{?proto.google.protobuf.Duration} */ ( + jspb.Message.getWrapperField(this, google_protobuf_duration_pb.Duration, 1)); +}; + + +/** + * @param {?proto.google.protobuf.Duration|undefined} value + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} returns this +*/ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.setInterval = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} returns this + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.clearInterval = function() { + return this.setInterval(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.hasInterval = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional uint32 max_retries = 2; + * @return {number} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.getMaxRetries = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} returns this + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.setMaxRetries = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.common.v1.JobFailurePolicyConstant} returns this + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.clearMaxRetries = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.common.v1.JobFailurePolicyConstant.prototype.hasMaxRetries = function() { + return jspb.Message.getField(this, 2) != null; }; diff --git a/src/proto/dapr/proto/internals/v1/apiversion_pb.js b/src/proto/dapr/proto/internals/v1/apiversion_pb.js index 31dbf02c..b1b02694 100644 --- a/src/proto/dapr/proto/internals/v1/apiversion_pb.js +++ b/src/proto/dapr/proto/internals/v1/apiversion_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); goog.exportSymbol('proto.dapr.proto.internals.v1.APIVersion', null, global); /** diff --git a/src/proto/dapr/proto/internals/v1/reminders.proto b/src/proto/dapr/proto/internals/v1/reminders.proto new file mode 100644 index 00000000..b285f7db --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/reminders.proto @@ -0,0 +1,47 @@ +/* +Copyright 2023 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. +*/ + +syntax = "proto3"; + +package dapr.proto.internals.v1; + +import "google/protobuf/timestamp.proto"; +import "google/protobuf/any.proto"; + +option go_package = "github.com/dapr/dapr/pkg/proto/internals/v1;internals"; + +// Reminder represents a reminder that is stored in the Dapr actor state store. +message Reminder { + string actor_id = 1; + string actor_type = 2; + string name = 3; + google.protobuf.Any data = 4; + string period = 5; + google.protobuf.Timestamp registered_time = 6; + string due_time = 7; + google.protobuf.Timestamp expiration_time = 8; + bool is_timer = 9; + bool skip_lock = 10; +} + +// Reminders is a collection of reminders. +message Reminders { + repeated Reminder reminders = 1; +} + +// TimerFiredEvent is the event that is sent to the actor when a timer fires. +message TimerFiredEvent { + google.protobuf.Timestamp fire_at = 1; + int32 timerId = 2; + uint64 generation = 3; +} diff --git a/src/proto/dapr/proto/internals/v1/reminders_grpc_pb.js b/src/proto/dapr/proto/internals/v1/reminders_grpc_pb.js new file mode 100644 index 00000000..97b3a246 --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/reminders_grpc_pb.js @@ -0,0 +1 @@ +// GENERATED CODE -- NO SERVICES IN PROTO \ No newline at end of file diff --git a/src/proto/dapr/proto/internals/v1/reminders_pb.d.ts b/src/proto/dapr/proto/internals/v1/reminders_pb.d.ts new file mode 100644 index 00000000..ab972cae --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/reminders_pb.d.ts @@ -0,0 +1,116 @@ +// package: dapr.proto.internals.v1 +// file: dapr/proto/internals/v1/reminders.proto + +/* tslint:disable */ +/* eslint-disable */ + +import * as jspb from "google-protobuf"; +import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb"; +import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb"; + +export class Reminder extends jspb.Message { + getActorId(): string; + setActorId(value: string): Reminder; + getActorType(): string; + setActorType(value: string): Reminder; + getName(): string; + setName(value: string): Reminder; + + hasData(): boolean; + clearData(): void; + getData(): google_protobuf_any_pb.Any | undefined; + setData(value?: google_protobuf_any_pb.Any): Reminder; + getPeriod(): string; + setPeriod(value: string): Reminder; + + hasRegisteredTime(): boolean; + clearRegisteredTime(): void; + getRegisteredTime(): google_protobuf_timestamp_pb.Timestamp | undefined; + setRegisteredTime(value?: google_protobuf_timestamp_pb.Timestamp): Reminder; + getDueTime(): string; + setDueTime(value: string): Reminder; + + hasExpirationTime(): boolean; + clearExpirationTime(): void; + getExpirationTime(): google_protobuf_timestamp_pb.Timestamp | undefined; + setExpirationTime(value?: google_protobuf_timestamp_pb.Timestamp): Reminder; + getIsTimer(): boolean; + setIsTimer(value: boolean): Reminder; + getSkipLock(): boolean; + setSkipLock(value: boolean): Reminder; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Reminder.AsObject; + static toObject(includeInstance: boolean, msg: Reminder): Reminder.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Reminder, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Reminder; + static deserializeBinaryFromReader(message: Reminder, reader: jspb.BinaryReader): Reminder; +} + +export namespace Reminder { + export type AsObject = { + actorId: string, + actorType: string, + name: string, + data?: google_protobuf_any_pb.Any.AsObject, + period: string, + registeredTime?: google_protobuf_timestamp_pb.Timestamp.AsObject, + dueTime: string, + expirationTime?: google_protobuf_timestamp_pb.Timestamp.AsObject, + isTimer: boolean, + skipLock: boolean, + } +} + +export class Reminders extends jspb.Message { + clearRemindersList(): void; + getRemindersList(): Array; + setRemindersList(value: Array): Reminders; + addReminders(value?: Reminder, index?: number): Reminder; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Reminders.AsObject; + static toObject(includeInstance: boolean, msg: Reminders): Reminders.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Reminders, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Reminders; + static deserializeBinaryFromReader(message: Reminders, reader: jspb.BinaryReader): Reminders; +} + +export namespace Reminders { + export type AsObject = { + remindersList: Array, + } +} + +export class TimerFiredEvent extends jspb.Message { + + hasFireAt(): boolean; + clearFireAt(): void; + getFireAt(): google_protobuf_timestamp_pb.Timestamp | undefined; + setFireAt(value?: google_protobuf_timestamp_pb.Timestamp): TimerFiredEvent; + getTimerid(): number; + setTimerid(value: number): TimerFiredEvent; + getGeneration(): number; + setGeneration(value: number): TimerFiredEvent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TimerFiredEvent.AsObject; + static toObject(includeInstance: boolean, msg: TimerFiredEvent): TimerFiredEvent.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: TimerFiredEvent, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TimerFiredEvent; + static deserializeBinaryFromReader(message: TimerFiredEvent, reader: jspb.BinaryReader): TimerFiredEvent; +} + +export namespace TimerFiredEvent { + export type AsObject = { + fireAt?: google_protobuf_timestamp_pb.Timestamp.AsObject, + timerid: number, + generation: number, + } +} diff --git a/src/proto/dapr/proto/internals/v1/reminders_pb.js b/src/proto/dapr/proto/internals/v1/reminders_pb.js new file mode 100644 index 00000000..87ea5367 --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/reminders_pb.js @@ -0,0 +1,928 @@ +// source: dapr/proto/internals/v1/reminders.proto +/** + * @fileoverview + * @enhanceable + * @suppress {missingRequire} reports error on implicit type usages. + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! +/* eslint-disable */ +// @ts-nocheck + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); + +var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js'); +goog.object.extend(proto, google_protobuf_timestamp_pb); +var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); +goog.object.extend(proto, google_protobuf_any_pb); +goog.exportSymbol('proto.dapr.proto.internals.v1.Reminder', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.Reminders', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.TimerFiredEvent', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.Reminder = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.Reminder, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.Reminder.displayName = 'proto.dapr.proto.internals.v1.Reminder'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.Reminders = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.internals.v1.Reminders.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.Reminders, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.Reminders.displayName = 'proto.dapr.proto.internals.v1.Reminders'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.TimerFiredEvent = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.TimerFiredEvent, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.TimerFiredEvent.displayName = 'proto.dapr.proto.internals.v1.TimerFiredEvent'; +} + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.Reminder.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.Reminder} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Reminder.toObject = function(includeInstance, msg) { + var f, obj = { + actorId: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorType: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, ""), + data: (f = msg.getData()) && google_protobuf_any_pb.Any.toObject(includeInstance, f), + period: jspb.Message.getFieldWithDefault(msg, 5, ""), + registeredTime: (f = msg.getRegisteredTime()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), + dueTime: jspb.Message.getFieldWithDefault(msg, 7, ""), + expirationTime: (f = msg.getExpirationTime()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), + isTimer: jspb.Message.getBooleanFieldWithDefault(msg, 9, false), + skipLock: jspb.Message.getBooleanFieldWithDefault(msg, 10, false) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.Reminder} + */ +proto.dapr.proto.internals.v1.Reminder.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.Reminder; + return proto.dapr.proto.internals.v1.Reminder.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.Reminder} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.Reminder} + */ +proto.dapr.proto.internals.v1.Reminder.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setActorId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setActorType(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 4: + var value = new google_protobuf_any_pb.Any; + reader.readMessage(value,google_protobuf_any_pb.Any.deserializeBinaryFromReader); + msg.setData(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setPeriod(value); + break; + case 6: + var value = new google_protobuf_timestamp_pb.Timestamp; + reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); + msg.setRegisteredTime(value); + break; + case 7: + var value = /** @type {string} */ (reader.readString()); + msg.setDueTime(value); + break; + case 8: + var value = new google_protobuf_timestamp_pb.Timestamp; + reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); + msg.setExpirationTime(value); + break; + case 9: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setIsTimer(value); + break; + case 10: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setSkipLock(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.Reminder.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.Reminder} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Reminder.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getActorId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getActorType(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getData(); + if (f != null) { + writer.writeMessage( + 4, + f, + google_protobuf_any_pb.Any.serializeBinaryToWriter + ); + } + f = message.getPeriod(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } + f = message.getRegisteredTime(); + if (f != null) { + writer.writeMessage( + 6, + f, + google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter + ); + } + f = message.getDueTime(); + if (f.length > 0) { + writer.writeString( + 7, + f + ); + } + f = message.getExpirationTime(); + if (f != null) { + writer.writeMessage( + 8, + f, + google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter + ); + } + f = message.getIsTimer(); + if (f) { + writer.writeBool( + 9, + f + ); + } + f = message.getSkipLock(); + if (f) { + writer.writeBool( + 10, + f + ); + } +}; + + +/** + * optional string actor_id = 1; + * @return {string} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getActorId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setActorId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string actor_type = 2; + * @return {string} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getActorType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setActorType = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string name = 3; + * @return {string} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional google.protobuf.Any data = 4; + * @return {?proto.google.protobuf.Any} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getData = function() { + return /** @type{?proto.google.protobuf.Any} */ ( + jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 4)); +}; + + +/** + * @param {?proto.google.protobuf.Any|undefined} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this +*/ +proto.dapr.proto.internals.v1.Reminder.prototype.setData = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.clearData = function() { + return this.setData(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.hasData = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional string period = 5; + * @return {string} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getPeriod = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setPeriod = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); +}; + + +/** + * optional google.protobuf.Timestamp registered_time = 6; + * @return {?proto.google.protobuf.Timestamp} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getRegisteredTime = function() { + return /** @type{?proto.google.protobuf.Timestamp} */ ( + jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 6)); +}; + + +/** + * @param {?proto.google.protobuf.Timestamp|undefined} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this +*/ +proto.dapr.proto.internals.v1.Reminder.prototype.setRegisteredTime = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.clearRegisteredTime = function() { + return this.setRegisteredTime(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.hasRegisteredTime = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * optional string due_time = 7; + * @return {string} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getDueTime = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setDueTime = function(value) { + return jspb.Message.setProto3StringField(this, 7, value); +}; + + +/** + * optional google.protobuf.Timestamp expiration_time = 8; + * @return {?proto.google.protobuf.Timestamp} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getExpirationTime = function() { + return /** @type{?proto.google.protobuf.Timestamp} */ ( + jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 8)); +}; + + +/** + * @param {?proto.google.protobuf.Timestamp|undefined} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this +*/ +proto.dapr.proto.internals.v1.Reminder.prototype.setExpirationTime = function(value) { + return jspb.Message.setWrapperField(this, 8, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.clearExpirationTime = function() { + return this.setExpirationTime(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.hasExpirationTime = function() { + return jspb.Message.getField(this, 8) != null; +}; + + +/** + * optional bool is_timer = 9; + * @return {boolean} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getIsTimer = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 9, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setIsTimer = function(value) { + return jspb.Message.setProto3BooleanField(this, 9, value); +}; + + +/** + * optional bool skip_lock = 10; + * @return {boolean} + */ +proto.dapr.proto.internals.v1.Reminder.prototype.getSkipLock = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 10, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.dapr.proto.internals.v1.Reminder} returns this + */ +proto.dapr.proto.internals.v1.Reminder.prototype.setSkipLock = function(value) { + return jspb.Message.setProto3BooleanField(this, 10, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.internals.v1.Reminders.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.Reminders.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.Reminders.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.Reminders} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Reminders.toObject = function(includeInstance, msg) { + var f, obj = { + remindersList: jspb.Message.toObjectList(msg.getRemindersList(), + proto.dapr.proto.internals.v1.Reminder.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.Reminders} + */ +proto.dapr.proto.internals.v1.Reminders.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.Reminders; + return proto.dapr.proto.internals.v1.Reminders.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.Reminders} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.Reminders} + */ +proto.dapr.proto.internals.v1.Reminders.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.internals.v1.Reminder; + reader.readMessage(value,proto.dapr.proto.internals.v1.Reminder.deserializeBinaryFromReader); + msg.addReminders(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.Reminders.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.Reminders.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.Reminders} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Reminders.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRemindersList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.dapr.proto.internals.v1.Reminder.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated Reminder reminders = 1; + * @return {!Array} + */ +proto.dapr.proto.internals.v1.Reminders.prototype.getRemindersList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.internals.v1.Reminder, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.internals.v1.Reminders} returns this +*/ +proto.dapr.proto.internals.v1.Reminders.prototype.setRemindersList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.internals.v1.Reminder=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.internals.v1.Reminder} + */ +proto.dapr.proto.internals.v1.Reminders.prototype.addReminders = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.internals.v1.Reminder, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.internals.v1.Reminders} returns this + */ +proto.dapr.proto.internals.v1.Reminders.prototype.clearRemindersList = function() { + return this.setRemindersList([]); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.TimerFiredEvent.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.TimerFiredEvent} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.toObject = function(includeInstance, msg) { + var f, obj = { + fireAt: (f = msg.getFireAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), + timerid: jspb.Message.getFieldWithDefault(msg, 2, 0), + generation: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.TimerFiredEvent; + return proto.dapr.proto.internals.v1.TimerFiredEvent.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.TimerFiredEvent} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new google_protobuf_timestamp_pb.Timestamp; + reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); + msg.setFireAt(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setTimerid(value); + break; + case 3: + var value = /** @type {number} */ (reader.readUint64()); + msg.setGeneration(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.TimerFiredEvent.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.TimerFiredEvent} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getFireAt(); + if (f != null) { + writer.writeMessage( + 1, + f, + google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter + ); + } + f = message.getTimerid(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getGeneration(); + if (f !== 0) { + writer.writeUint64( + 3, + f + ); + } +}; + + +/** + * optional google.protobuf.Timestamp fire_at = 1; + * @return {?proto.google.protobuf.Timestamp} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.getFireAt = function() { + return /** @type{?proto.google.protobuf.Timestamp} */ ( + jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 1)); +}; + + +/** + * @param {?proto.google.protobuf.Timestamp|undefined} value + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} returns this +*/ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.setFireAt = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} returns this + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.clearFireAt = function() { + return this.setFireAt(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.hasFireAt = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional int32 timerId = 2; + * @return {number} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.getTimerid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} returns this + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.setTimerid = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional uint64 generation = 3; + * @return {number} + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.getGeneration = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.internals.v1.TimerFiredEvent} returns this + */ +proto.dapr.proto.internals.v1.TimerFiredEvent.prototype.setGeneration = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +goog.object.extend(exports, proto.dapr.proto.internals.v1); diff --git a/src/proto/dapr/proto/internals/v1/service_invocation.proto b/src/proto/dapr/proto/internals/v1/service_invocation.proto index b45c31d6..d764e18c 100644 --- a/src/proto/dapr/proto/internals/v1/service_invocation.proto +++ b/src/proto/dapr/proto/internals/v1/service_invocation.proto @@ -53,6 +53,10 @@ service ServiceInvocation { // - When the sender has completed sending the data, it MUST call `CloseSend` on the stream. // The caller and callee must send at least one message in the stream. If only 1 message is sent in each direction, that message must contain both a `request`/`response` (the `payload` may be empty). rpc CallLocalStream (stream InternalInvokeRequestStream) returns (stream InternalInvokeResponseStream) {} + + // CallActorStream is used to invoke actor method with request and streaming + // response. + rpc CallActorStream (InternalInvokeRequest) returns (stream InternalInvokeResponse) {} } // Actor represents actor using actor_type and actor_id diff --git a/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.d.ts b/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.d.ts new file mode 100644 index 00000000..399a70ae --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.d.ts @@ -0,0 +1,111 @@ +// package: dapr.proto.internals.v1 +// file: dapr/proto/internals/v1/service_invocation.proto + +/* tslint:disable */ +/* eslint-disable */ + +import * as grpc from "@grpc/grpc-js"; +import * as dapr_proto_internals_v1_service_invocation_pb from "../../../../dapr/proto/internals/v1/service_invocation_pb"; +import * as dapr_proto_common_v1_common_pb from "../../../../dapr/proto/common/v1/common_pb"; +import * as dapr_proto_internals_v1_reminders_pb from "../../../../dapr/proto/internals/v1/reminders_pb"; +import * as dapr_proto_internals_v1_apiversion_pb from "../../../../dapr/proto/internals/v1/apiversion_pb"; +import * as dapr_proto_internals_v1_status_pb from "../../../../dapr/proto/internals/v1/status_pb"; +import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb"; + +interface IServiceInvocationService extends grpc.ServiceDefinition { + callActor: IServiceInvocationService_ICallActor; + callLocal: IServiceInvocationService_ICallLocal; + callActorReminder: IServiceInvocationService_ICallActorReminder; + callLocalStream: IServiceInvocationService_ICallLocalStream; + callActorStream: IServiceInvocationService_ICallActorStream; +} + +interface IServiceInvocationService_ICallActor extends grpc.MethodDefinition { + path: "/dapr.proto.internals.v1.ServiceInvocation/CallActor"; + requestStream: false; + responseStream: false; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} +interface IServiceInvocationService_ICallLocal extends grpc.MethodDefinition { + path: "/dapr.proto.internals.v1.ServiceInvocation/CallLocal"; + requestStream: false; + responseStream: false; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} +interface IServiceInvocationService_ICallActorReminder extends grpc.MethodDefinition { + path: "/dapr.proto.internals.v1.ServiceInvocation/CallActorReminder"; + requestStream: false; + responseStream: false; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} +interface IServiceInvocationService_ICallLocalStream extends grpc.MethodDefinition { + path: "/dapr.proto.internals.v1.ServiceInvocation/CallLocalStream"; + requestStream: true; + responseStream: true; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} +interface IServiceInvocationService_ICallActorStream extends grpc.MethodDefinition { + path: "/dapr.proto.internals.v1.ServiceInvocation/CallActorStream"; + requestStream: false; + responseStream: true; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} + +export const ServiceInvocationService: IServiceInvocationService; + +export interface IServiceInvocationServer extends grpc.UntypedServiceImplementation { + callActor: grpc.handleUnaryCall; + callLocal: grpc.handleUnaryCall; + callActorReminder: grpc.handleUnaryCall; + callLocalStream: grpc.handleBidiStreamingCall; + callActorStream: grpc.handleServerStreamingCall; +} + +export interface IServiceInvocationClient { + callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + callLocalStream(): grpc.ClientDuplexStream; + callLocalStream(options: Partial): grpc.ClientDuplexStream; + callLocalStream(metadata: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; + callActorStream(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, options?: Partial): grpc.ClientReadableStream; + callActorStream(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; +} + +export class ServiceInvocationClient extends grpc.Client implements IServiceInvocationClient { + constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial); + public callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callActor(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callLocal(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse) => void): grpc.ClientUnaryCall; + public callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + public callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + public callActorReminder(request: dapr_proto_internals_v1_reminders_pb.Reminder, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall; + public callLocalStream(options?: Partial): grpc.ClientDuplexStream; + public callLocalStream(metadata?: grpc.Metadata, options?: Partial): grpc.ClientDuplexStream; + public callActorStream(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, options?: Partial): grpc.ClientReadableStream; + public callActorStream(request: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; +} diff --git a/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.js b/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.js new file mode 100644 index 00000000..2b91fd3e --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/service_invocation_grpc_pb.js @@ -0,0 +1,174 @@ +// GENERATED CODE -- DO NOT EDIT! + +// Original file comments: +// +// 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. +// +'use strict'; +var grpc = require('@grpc/grpc-js'); +var dapr_proto_internals_v1_service_invocation_pb = require('../../../../dapr/proto/internals/v1/service_invocation_pb.js'); +var dapr_proto_common_v1_common_pb = require('../../../../dapr/proto/common/v1/common_pb.js'); +var dapr_proto_internals_v1_reminders_pb = require('../../../../dapr/proto/internals/v1/reminders_pb.js'); +var dapr_proto_internals_v1_apiversion_pb = require('../../../../dapr/proto/internals/v1/apiversion_pb.js'); +var dapr_proto_internals_v1_status_pb = require('../../../../dapr/proto/internals/v1/status_pb.js'); +var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js'); + +function serialize_dapr_proto_internals_v1_InternalInvokeRequest(arg) { + if (!(arg instanceof dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest)) { + throw new Error('Expected argument of type dapr.proto.internals.v1.InternalInvokeRequest'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_internals_v1_InternalInvokeRequest(buffer_arg) { + return dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_internals_v1_InternalInvokeRequestStream(arg) { + if (!(arg instanceof dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequestStream)) { + throw new Error('Expected argument of type dapr.proto.internals.v1.InternalInvokeRequestStream'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_internals_v1_InternalInvokeRequestStream(buffer_arg) { + return dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequestStream.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_internals_v1_InternalInvokeResponse(arg) { + if (!(arg instanceof dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse)) { + throw new Error('Expected argument of type dapr.proto.internals.v1.InternalInvokeResponse'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_internals_v1_InternalInvokeResponse(buffer_arg) { + return dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_internals_v1_InternalInvokeResponseStream(arg) { + if (!(arg instanceof dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponseStream)) { + throw new Error('Expected argument of type dapr.proto.internals.v1.InternalInvokeResponseStream'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_internals_v1_InternalInvokeResponseStream(buffer_arg) { + return dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponseStream.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_internals_v1_Reminder(arg) { + if (!(arg instanceof dapr_proto_internals_v1_reminders_pb.Reminder)) { + throw new Error('Expected argument of type dapr.proto.internals.v1.Reminder'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_internals_v1_Reminder(buffer_arg) { + return dapr_proto_internals_v1_reminders_pb.Reminder.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_google_protobuf_Empty(arg) { + if (!(arg instanceof google_protobuf_empty_pb.Empty)) { + throw new Error('Expected argument of type google.protobuf.Empty'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_google_protobuf_Empty(buffer_arg) { + return google_protobuf_empty_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg)); +} + + +// ServiceInvocation service is used to exchange the data between +// caller dapr runtime and callee dapr runtime. +// +// The request message includes caller's HTTP/gRPC request +// and deliver callee's response including status code. +// The response status of rpc methods represents of internal gRPC +// connection status, not callee's response status. +// +// Thus, ServiceInvocation gRPC response returns OK in most cases +// regardless of callee's response. +var ServiceInvocationService = exports.ServiceInvocationService = { + // Invokes a method of the specific actor. +callActor: { + path: '/dapr.proto.internals.v1.ServiceInvocation/CallActor', + requestStream: false, + responseStream: false, + requestType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, + responseType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse, + requestSerialize: serialize_dapr_proto_internals_v1_InternalInvokeRequest, + requestDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeRequest, + responseSerialize: serialize_dapr_proto_internals_v1_InternalInvokeResponse, + responseDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeResponse, + }, + // Invokes a method of the specific service. +callLocal: { + path: '/dapr.proto.internals.v1.ServiceInvocation/CallLocal', + requestStream: false, + responseStream: false, + requestType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, + responseType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse, + requestSerialize: serialize_dapr_proto_internals_v1_InternalInvokeRequest, + requestDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeRequest, + responseSerialize: serialize_dapr_proto_internals_v1_InternalInvokeResponse, + responseDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeResponse, + }, + // Invoke a remote internal actor reminder +callActorReminder: { + path: '/dapr.proto.internals.v1.ServiceInvocation/CallActorReminder', + requestStream: false, + responseStream: false, + requestType: dapr_proto_internals_v1_reminders_pb.Reminder, + responseType: google_protobuf_empty_pb.Empty, + requestSerialize: serialize_dapr_proto_internals_v1_Reminder, + requestDeserialize: deserialize_dapr_proto_internals_v1_Reminder, + responseSerialize: serialize_google_protobuf_Empty, + responseDeserialize: deserialize_google_protobuf_Empty, + }, + // Invokes a method of the specific service using a stream of data. +// Although this uses a bi-directional stream, it behaves as a "simple RPC" in which the caller sends the full request (chunked in multiple messages in the stream), then reads the full response (chunked in the stream). +// Each message in the stream contains a `InternalInvokeRequestStream` (for caller) or `InternalInvokeResponseStream` (for callee): +// - The first message in the stream MUST contain a `request` (caller) or `response` (callee) message with all required properties present. +// - The first message in the stream MAY contain a `payload`, which is not required and may be empty. +// - Subsequent messages (any message except the first one in the stream) MUST contain a `payload` and MUST NOT contain any other property (like `request` or `response`). +// - Each message with a `payload` MUST contain a sequence number in `seq`, which is a counter that starts from 0 and MUST be incremented by 1 in each chunk. The `seq` counter MUST NOT be included if the message does not have a `payload`. +// - When the sender has completed sending the data, it MUST call `CloseSend` on the stream. +// The caller and callee must send at least one message in the stream. If only 1 message is sent in each direction, that message must contain both a `request`/`response` (the `payload` may be empty). +callLocalStream: { + path: '/dapr.proto.internals.v1.ServiceInvocation/CallLocalStream', + requestStream: true, + responseStream: true, + requestType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequestStream, + responseType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponseStream, + requestSerialize: serialize_dapr_proto_internals_v1_InternalInvokeRequestStream, + requestDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeRequestStream, + responseSerialize: serialize_dapr_proto_internals_v1_InternalInvokeResponseStream, + responseDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeResponseStream, + }, + // CallActorStream is used to invoke actor method with request and streaming +// response. +callActorStream: { + path: '/dapr.proto.internals.v1.ServiceInvocation/CallActorStream', + requestStream: false, + responseStream: true, + requestType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeRequest, + responseType: dapr_proto_internals_v1_service_invocation_pb.InternalInvokeResponse, + requestSerialize: serialize_dapr_proto_internals_v1_InternalInvokeRequest, + requestDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeRequest, + responseSerialize: serialize_dapr_proto_internals_v1_InternalInvokeResponse, + responseDeserialize: deserialize_dapr_proto_internals_v1_InternalInvokeResponse, + }, +}; + +exports.ServiceInvocationClient = grpc.makeGenericClientConstructor(ServiceInvocationService, 'ServiceInvocation'); diff --git a/src/proto/dapr/proto/internals/v1/service_invocation_pb.d.ts b/src/proto/dapr/proto/internals/v1/service_invocation_pb.d.ts new file mode 100644 index 00000000..3c06d024 --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/service_invocation_pb.d.ts @@ -0,0 +1,191 @@ +// package: dapr.proto.internals.v1 +// file: dapr/proto/internals/v1/service_invocation.proto + +/* tslint:disable */ +/* eslint-disable */ + +import * as jspb from "google-protobuf"; +import * as dapr_proto_common_v1_common_pb from "../../../../dapr/proto/common/v1/common_pb"; +import * as dapr_proto_internals_v1_reminders_pb from "../../../../dapr/proto/internals/v1/reminders_pb"; +import * as dapr_proto_internals_v1_apiversion_pb from "../../../../dapr/proto/internals/v1/apiversion_pb"; +import * as dapr_proto_internals_v1_status_pb from "../../../../dapr/proto/internals/v1/status_pb"; +import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb"; + +export class Actor extends jspb.Message { + getActorType(): string; + setActorType(value: string): Actor; + getActorId(): string; + setActorId(value: string): Actor; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Actor.AsObject; + static toObject(includeInstance: boolean, msg: Actor): Actor.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Actor, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Actor; + static deserializeBinaryFromReader(message: Actor, reader: jspb.BinaryReader): Actor; +} + +export namespace Actor { + export type AsObject = { + actorType: string, + actorId: string, + } +} + +export class InternalInvokeRequest extends jspb.Message { + getVer(): dapr_proto_internals_v1_apiversion_pb.APIVersion; + setVer(value: dapr_proto_internals_v1_apiversion_pb.APIVersion): InternalInvokeRequest; + + getMetadataMap(): jspb.Map; + clearMetadataMap(): void; + + hasMessage(): boolean; + clearMessage(): void; + getMessage(): dapr_proto_common_v1_common_pb.InvokeRequest | undefined; + setMessage(value?: dapr_proto_common_v1_common_pb.InvokeRequest): InternalInvokeRequest; + + hasActor(): boolean; + clearActor(): void; + getActor(): Actor | undefined; + setActor(value?: Actor): InternalInvokeRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InternalInvokeRequest.AsObject; + static toObject(includeInstance: boolean, msg: InternalInvokeRequest): InternalInvokeRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: InternalInvokeRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InternalInvokeRequest; + static deserializeBinaryFromReader(message: InternalInvokeRequest, reader: jspb.BinaryReader): InternalInvokeRequest; +} + +export namespace InternalInvokeRequest { + export type AsObject = { + ver: dapr_proto_internals_v1_apiversion_pb.APIVersion, + + metadataMap: Array<[string, ListStringValue.AsObject]>, + message?: dapr_proto_common_v1_common_pb.InvokeRequest.AsObject, + actor?: Actor.AsObject, + } +} + +export class InternalInvokeResponse extends jspb.Message { + + hasStatus(): boolean; + clearStatus(): void; + getStatus(): dapr_proto_internals_v1_status_pb.Status | undefined; + setStatus(value?: dapr_proto_internals_v1_status_pb.Status): InternalInvokeResponse; + + getHeadersMap(): jspb.Map; + clearHeadersMap(): void; + + getTrailersMap(): jspb.Map; + clearTrailersMap(): void; + + hasMessage(): boolean; + clearMessage(): void; + getMessage(): dapr_proto_common_v1_common_pb.InvokeResponse | undefined; + setMessage(value?: dapr_proto_common_v1_common_pb.InvokeResponse): InternalInvokeResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InternalInvokeResponse.AsObject; + static toObject(includeInstance: boolean, msg: InternalInvokeResponse): InternalInvokeResponse.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: InternalInvokeResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InternalInvokeResponse; + static deserializeBinaryFromReader(message: InternalInvokeResponse, reader: jspb.BinaryReader): InternalInvokeResponse; +} + +export namespace InternalInvokeResponse { + export type AsObject = { + status?: dapr_proto_internals_v1_status_pb.Status.AsObject, + + headersMap: Array<[string, ListStringValue.AsObject]>, + + trailersMap: Array<[string, ListStringValue.AsObject]>, + message?: dapr_proto_common_v1_common_pb.InvokeResponse.AsObject, + } +} + +export class InternalInvokeRequestStream extends jspb.Message { + + hasRequest(): boolean; + clearRequest(): void; + getRequest(): InternalInvokeRequest | undefined; + setRequest(value?: InternalInvokeRequest): InternalInvokeRequestStream; + + hasPayload(): boolean; + clearPayload(): void; + getPayload(): dapr_proto_common_v1_common_pb.StreamPayload | undefined; + setPayload(value?: dapr_proto_common_v1_common_pb.StreamPayload): InternalInvokeRequestStream; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InternalInvokeRequestStream.AsObject; + static toObject(includeInstance: boolean, msg: InternalInvokeRequestStream): InternalInvokeRequestStream.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: InternalInvokeRequestStream, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InternalInvokeRequestStream; + static deserializeBinaryFromReader(message: InternalInvokeRequestStream, reader: jspb.BinaryReader): InternalInvokeRequestStream; +} + +export namespace InternalInvokeRequestStream { + export type AsObject = { + request?: InternalInvokeRequest.AsObject, + payload?: dapr_proto_common_v1_common_pb.StreamPayload.AsObject, + } +} + +export class InternalInvokeResponseStream extends jspb.Message { + + hasResponse(): boolean; + clearResponse(): void; + getResponse(): InternalInvokeResponse | undefined; + setResponse(value?: InternalInvokeResponse): InternalInvokeResponseStream; + + hasPayload(): boolean; + clearPayload(): void; + getPayload(): dapr_proto_common_v1_common_pb.StreamPayload | undefined; + setPayload(value?: dapr_proto_common_v1_common_pb.StreamPayload): InternalInvokeResponseStream; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InternalInvokeResponseStream.AsObject; + static toObject(includeInstance: boolean, msg: InternalInvokeResponseStream): InternalInvokeResponseStream.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: InternalInvokeResponseStream, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InternalInvokeResponseStream; + static deserializeBinaryFromReader(message: InternalInvokeResponseStream, reader: jspb.BinaryReader): InternalInvokeResponseStream; +} + +export namespace InternalInvokeResponseStream { + export type AsObject = { + response?: InternalInvokeResponse.AsObject, + payload?: dapr_proto_common_v1_common_pb.StreamPayload.AsObject, + } +} + +export class ListStringValue extends jspb.Message { + clearValuesList(): void; + getValuesList(): Array; + setValuesList(value: Array): ListStringValue; + addValues(value: string, index?: number): string; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListStringValue.AsObject; + static toObject(includeInstance: boolean, msg: ListStringValue): ListStringValue.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ListStringValue, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListStringValue; + static deserializeBinaryFromReader(message: ListStringValue, reader: jspb.BinaryReader): ListStringValue; +} + +export namespace ListStringValue { + export type AsObject = { + valuesList: Array, + } +} diff --git a/src/proto/dapr/proto/internals/v1/service_invocation_pb.js b/src/proto/dapr/proto/internals/v1/service_invocation_pb.js new file mode 100644 index 00000000..ef68ba10 --- /dev/null +++ b/src/proto/dapr/proto/internals/v1/service_invocation_pb.js @@ -0,0 +1,1419 @@ +// source: dapr/proto/internals/v1/service_invocation.proto +/** + * @fileoverview + * @enhanceable + * @suppress {missingRequire} reports error on implicit type usages. + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. + * @public + */ +// GENERATED CODE -- DO NOT EDIT! +/* eslint-disable */ +// @ts-nocheck + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); + +var dapr_proto_common_v1_common_pb = require('../../../../dapr/proto/common/v1/common_pb.js'); +goog.object.extend(proto, dapr_proto_common_v1_common_pb); +var dapr_proto_internals_v1_reminders_pb = require('../../../../dapr/proto/internals/v1/reminders_pb.js'); +goog.object.extend(proto, dapr_proto_internals_v1_reminders_pb); +var dapr_proto_internals_v1_apiversion_pb = require('../../../../dapr/proto/internals/v1/apiversion_pb.js'); +goog.object.extend(proto, dapr_proto_internals_v1_apiversion_pb); +var dapr_proto_internals_v1_status_pb = require('../../../../dapr/proto/internals/v1/status_pb.js'); +goog.object.extend(proto, dapr_proto_internals_v1_status_pb); +var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js'); +goog.object.extend(proto, google_protobuf_empty_pb); +goog.exportSymbol('proto.dapr.proto.internals.v1.Actor', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.InternalInvokeRequest', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.InternalInvokeRequestStream', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.InternalInvokeResponse', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.InternalInvokeResponseStream', null, global); +goog.exportSymbol('proto.dapr.proto.internals.v1.ListStringValue', null, global); +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.Actor = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.Actor, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.Actor.displayName = 'proto.dapr.proto.internals.v1.Actor'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.InternalInvokeRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.InternalInvokeRequest.displayName = 'proto.dapr.proto.internals.v1.InternalInvokeRequest'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.InternalInvokeResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.InternalInvokeResponse.displayName = 'proto.dapr.proto.internals.v1.InternalInvokeResponse'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.InternalInvokeRequestStream, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.InternalInvokeRequestStream.displayName = 'proto.dapr.proto.internals.v1.InternalInvokeRequestStream'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.InternalInvokeResponseStream, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.InternalInvokeResponseStream.displayName = 'proto.dapr.proto.internals.v1.InternalInvokeResponseStream'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.internals.v1.ListStringValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.internals.v1.ListStringValue.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.internals.v1.ListStringValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.internals.v1.ListStringValue.displayName = 'proto.dapr.proto.internals.v1.ListStringValue'; +} + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.Actor.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.Actor.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.Actor} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Actor.toObject = function(includeInstance, msg) { + var f, obj = { + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.Actor} + */ +proto.dapr.proto.internals.v1.Actor.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.Actor; + return proto.dapr.proto.internals.v1.Actor.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.Actor} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.Actor} + */ +proto.dapr.proto.internals.v1.Actor.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setActorType(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setActorId(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.Actor.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.Actor.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.Actor} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.Actor.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getActorType(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getActorId(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string actor_type = 1; + * @return {string} + */ +proto.dapr.proto.internals.v1.Actor.prototype.getActorType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Actor} returns this + */ +proto.dapr.proto.internals.v1.Actor.prototype.setActorType = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string actor_id = 2; + * @return {string} + */ +proto.dapr.proto.internals.v1.Actor.prototype.getActorId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.internals.v1.Actor} returns this + */ +proto.dapr.proto.internals.v1.Actor.prototype.setActorId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.InternalInvokeRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.toObject = function(includeInstance, msg) { + var f, obj = { + ver: jspb.Message.getFieldWithDefault(msg, 1, 0), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, proto.dapr.proto.internals.v1.ListStringValue.toObject) : [], + message: (f = msg.getMessage()) && dapr_proto_common_v1_common_pb.InvokeRequest.toObject(includeInstance, f), + actor: (f = msg.getActor()) && proto.dapr.proto.internals.v1.Actor.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.InternalInvokeRequest; + return proto.dapr.proto.internals.v1.InternalInvokeRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.dapr.proto.internals.v1.APIVersion} */ (reader.readEnum()); + msg.setVer(value); + break; + case 2: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.internals.v1.ListStringValue.deserializeBinaryFromReader, "", new proto.dapr.proto.internals.v1.ListStringValue()); + }); + break; + case 3: + var value = new dapr_proto_common_v1_common_pb.InvokeRequest; + reader.readMessage(value,dapr_proto_common_v1_common_pb.InvokeRequest.deserializeBinaryFromReader); + msg.setMessage(value); + break; + case 4: + var value = new proto.dapr.proto.internals.v1.Actor; + reader.readMessage(value,proto.dapr.proto.internals.v1.Actor.deserializeBinaryFromReader); + msg.setActor(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.InternalInvokeRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getVer(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.internals.v1.ListStringValue.serializeBinaryToWriter); + } + f = message.getMessage(); + if (f != null) { + writer.writeMessage( + 3, + f, + dapr_proto_common_v1_common_pb.InvokeRequest.serializeBinaryToWriter + ); + } + f = message.getActor(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.dapr.proto.internals.v1.Actor.serializeBinaryToWriter + ); + } +}; + + +/** + * optional APIVersion ver = 1; + * @return {!proto.dapr.proto.internals.v1.APIVersion} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.getVer = function() { + return /** @type {!proto.dapr.proto.internals.v1.APIVersion} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {!proto.dapr.proto.internals.v1.APIVersion} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.setVer = function(value) { + return jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * map metadata = 2; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 2, opt_noLazyCreate, + proto.dapr.proto.internals.v1.ListStringValue)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + +/** + * optional dapr.proto.common.v1.InvokeRequest message = 3; + * @return {?proto.dapr.proto.common.v1.InvokeRequest} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.getMessage = function() { + return /** @type{?proto.dapr.proto.common.v1.InvokeRequest} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.InvokeRequest, 3)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.InvokeRequest|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.setMessage = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.clearMessage = function() { + return this.setMessage(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.hasMessage = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * optional Actor actor = 4; + * @return {?proto.dapr.proto.internals.v1.Actor} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.getActor = function() { + return /** @type{?proto.dapr.proto.internals.v1.Actor} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.internals.v1.Actor, 4)); +}; + + +/** + * @param {?proto.dapr.proto.internals.v1.Actor|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.setActor = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequest} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.clearActor = function() { + return this.setActor(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequest.prototype.hasActor = function() { + return jspb.Message.getField(this, 4) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.InternalInvokeResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.toObject = function(includeInstance, msg) { + var f, obj = { + status: (f = msg.getStatus()) && dapr_proto_internals_v1_status_pb.Status.toObject(includeInstance, f), + headersMap: (f = msg.getHeadersMap()) ? f.toObject(includeInstance, proto.dapr.proto.internals.v1.ListStringValue.toObject) : [], + trailersMap: (f = msg.getTrailersMap()) ? f.toObject(includeInstance, proto.dapr.proto.internals.v1.ListStringValue.toObject) : [], + message: (f = msg.getMessage()) && dapr_proto_common_v1_common_pb.InvokeResponse.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.InternalInvokeResponse; + return proto.dapr.proto.internals.v1.InternalInvokeResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new dapr_proto_internals_v1_status_pb.Status; + reader.readMessage(value,dapr_proto_internals_v1_status_pb.Status.deserializeBinaryFromReader); + msg.setStatus(value); + break; + case 2: + var value = msg.getHeadersMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.internals.v1.ListStringValue.deserializeBinaryFromReader, "", new proto.dapr.proto.internals.v1.ListStringValue()); + }); + break; + case 3: + var value = msg.getTrailersMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.internals.v1.ListStringValue.deserializeBinaryFromReader, "", new proto.dapr.proto.internals.v1.ListStringValue()); + }); + break; + case 4: + var value = new dapr_proto_common_v1_common_pb.InvokeResponse; + reader.readMessage(value,dapr_proto_common_v1_common_pb.InvokeResponse.deserializeBinaryFromReader); + msg.setMessage(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.InternalInvokeResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStatus(); + if (f != null) { + writer.writeMessage( + 1, + f, + dapr_proto_internals_v1_status_pb.Status.serializeBinaryToWriter + ); + } + f = message.getHeadersMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.internals.v1.ListStringValue.serializeBinaryToWriter); + } + f = message.getTrailersMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.internals.v1.ListStringValue.serializeBinaryToWriter); + } + f = message.getMessage(); + if (f != null) { + writer.writeMessage( + 4, + f, + dapr_proto_common_v1_common_pb.InvokeResponse.serializeBinaryToWriter + ); + } +}; + + +/** + * optional Status status = 1; + * @return {?proto.dapr.proto.internals.v1.Status} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.getStatus = function() { + return /** @type{?proto.dapr.proto.internals.v1.Status} */ ( + jspb.Message.getWrapperField(this, dapr_proto_internals_v1_status_pb.Status, 1)); +}; + + +/** + * @param {?proto.dapr.proto.internals.v1.Status|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.setStatus = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.clearStatus = function() { + return this.setStatus(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.hasStatus = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * map headers = 2; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.getHeadersMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 2, opt_noLazyCreate, + proto.dapr.proto.internals.v1.ListStringValue)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.clearHeadersMap = function() { + this.getHeadersMap().clear(); + return this;}; + + +/** + * map trailers = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.getTrailersMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + proto.dapr.proto.internals.v1.ListStringValue)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.clearTrailersMap = function() { + this.getTrailersMap().clear(); + return this;}; + + +/** + * optional dapr.proto.common.v1.InvokeResponse message = 4; + * @return {?proto.dapr.proto.common.v1.InvokeResponse} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.getMessage = function() { + return /** @type{?proto.dapr.proto.common.v1.InvokeResponse} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.InvokeResponse, 4)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.InvokeResponse|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.setMessage = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponse} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.clearMessage = function() { + return this.setMessage(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponse.prototype.hasMessage = function() { + return jspb.Message.getField(this, 4) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.InternalInvokeRequestStream.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.toObject = function(includeInstance, msg) { + var f, obj = { + request: (f = msg.getRequest()) && proto.dapr.proto.internals.v1.InternalInvokeRequest.toObject(includeInstance, f), + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.InternalInvokeRequestStream; + return proto.dapr.proto.internals.v1.InternalInvokeRequestStream.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.internals.v1.InternalInvokeRequest; + reader.readMessage(value,proto.dapr.proto.internals.v1.InternalInvokeRequest.deserializeBinaryFromReader); + msg.setRequest(value); + break; + case 2: + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.InternalInvokeRequestStream.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRequest(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.dapr.proto.internals.v1.InternalInvokeRequest.serializeBinaryToWriter + ); + } + f = message.getPayload(); + if (f != null) { + writer.writeMessage( + 2, + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter + ); + } +}; + + +/** + * optional InternalInvokeRequest request = 1; + * @return {?proto.dapr.proto.internals.v1.InternalInvokeRequest} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.getRequest = function() { + return /** @type{?proto.dapr.proto.internals.v1.InternalInvokeRequest} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.internals.v1.InternalInvokeRequest, 1)); +}; + + +/** + * @param {?proto.dapr.proto.internals.v1.InternalInvokeRequest|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.setRequest = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.clearRequest = function() { + return this.setRequest(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.hasRequest = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional dapr.proto.common.v1.StreamPayload payload = 2; + * @return {?proto.dapr.proto.common.v1.StreamPayload} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeRequestStream} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.clearPayload = function() { + return this.setPayload(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeRequestStream.prototype.hasPayload = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.InternalInvokeResponseStream.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.toObject = function(includeInstance, msg) { + var f, obj = { + response: (f = msg.getResponse()) && proto.dapr.proto.internals.v1.InternalInvokeResponse.toObject(includeInstance, f), + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.InternalInvokeResponseStream; + return proto.dapr.proto.internals.v1.InternalInvokeResponseStream.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.internals.v1.InternalInvokeResponse; + reader.readMessage(value,proto.dapr.proto.internals.v1.InternalInvokeResponse.deserializeBinaryFromReader); + msg.setResponse(value); + break; + case 2: + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.InternalInvokeResponseStream.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getResponse(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.dapr.proto.internals.v1.InternalInvokeResponse.serializeBinaryToWriter + ); + } + f = message.getPayload(); + if (f != null) { + writer.writeMessage( + 2, + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter + ); + } +}; + + +/** + * optional InternalInvokeResponse response = 1; + * @return {?proto.dapr.proto.internals.v1.InternalInvokeResponse} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.getResponse = function() { + return /** @type{?proto.dapr.proto.internals.v1.InternalInvokeResponse} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.internals.v1.InternalInvokeResponse, 1)); +}; + + +/** + * @param {?proto.dapr.proto.internals.v1.InternalInvokeResponse|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.setResponse = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.clearResponse = function() { + return this.setResponse(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.hasResponse = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional dapr.proto.common.v1.StreamPayload payload = 2; + * @return {?proto.dapr.proto.common.v1.StreamPayload} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} returns this +*/ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.internals.v1.InternalInvokeResponseStream} returns this + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.clearPayload = function() { + return this.setPayload(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.internals.v1.InternalInvokeResponseStream.prototype.hasPayload = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.internals.v1.ListStringValue.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.internals.v1.ListStringValue.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.internals.v1.ListStringValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.ListStringValue.toObject = function(includeInstance, msg) { + var f, obj = { + valuesList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.internals.v1.ListStringValue} + */ +proto.dapr.proto.internals.v1.ListStringValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.internals.v1.ListStringValue; + return proto.dapr.proto.internals.v1.ListStringValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.internals.v1.ListStringValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.internals.v1.ListStringValue} + */ +proto.dapr.proto.internals.v1.ListStringValue.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.addValues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.internals.v1.ListStringValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.internals.v1.ListStringValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.internals.v1.ListStringValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValuesList(); + if (f.length > 0) { + writer.writeRepeatedString( + 1, + f + ); + } +}; + + +/** + * repeated string values = 1; + * @return {!Array} + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.getValuesList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.internals.v1.ListStringValue} returns this + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.setValuesList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.dapr.proto.internals.v1.ListStringValue} returns this + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.addValues = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.internals.v1.ListStringValue} returns this + */ +proto.dapr.proto.internals.v1.ListStringValue.prototype.clearValuesList = function() { + return this.setValuesList([]); +}; + + +goog.object.extend(exports, proto.dapr.proto.internals.v1); diff --git a/src/proto/dapr/proto/internals/v1/status_pb.js b/src/proto/dapr/proto/internals/v1/status_pb.js index bb945491..9253d7af 100644 --- a/src/proto/dapr/proto/internals/v1/status_pb.js +++ b/src/proto/dapr/proto/internals/v1/status_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); goog.object.extend(proto, google_protobuf_any_pb); diff --git a/src/proto/dapr/proto/operator/v1/operator_grpc_pb.js b/src/proto/dapr/proto/operator/v1/operator_grpc_pb.js index f3ceca92..75c2b70b 100644 --- a/src/proto/dapr/proto/operator/v1/operator_grpc_pb.js +++ b/src/proto/dapr/proto/operator/v1/operator_grpc_pb.js @@ -351,4 +351,4 @@ hTTPEndpointUpdate: { }, }; -exports.OperatorClient = grpc.makeGenericClientConstructor(OperatorService); +exports.OperatorClient = grpc.makeGenericClientConstructor(OperatorService, 'Operator'); diff --git a/src/proto/dapr/proto/operator/v1/operator_pb.js b/src/proto/dapr/proto/operator/v1/operator_pb.js index d983c9c3..1bb4fd81 100644 --- a/src/proto/dapr/proto/operator/v1/operator_pb.js +++ b/src/proto/dapr/proto/operator/v1/operator_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js'); goog.object.extend(proto, google_protobuf_empty_pb); diff --git a/src/proto/dapr/proto/placement/v1/placement_grpc_pb.js b/src/proto/dapr/proto/placement/v1/placement_grpc_pb.js index 3bc7ac5d..de9bd2ec 100644 --- a/src/proto/dapr/proto/placement/v1/placement_grpc_pb.js +++ b/src/proto/dapr/proto/placement/v1/placement_grpc_pb.js @@ -56,4 +56,4 @@ reportDaprStatus: { }, }; -exports.PlacementClient = grpc.makeGenericClientConstructor(PlacementService); +exports.PlacementClient = grpc.makeGenericClientConstructor(PlacementService, 'Placement'); diff --git a/src/proto/dapr/proto/placement/v1/placement_pb.js b/src/proto/dapr/proto/placement/v1/placement_pb.js index f234416f..1c2f9535 100644 --- a/src/proto/dapr/proto/placement/v1/placement_pb.js +++ b/src/proto/dapr/proto/placement/v1/placement_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); goog.exportSymbol('proto.dapr.proto.placement.v1.Host', null, global); goog.exportSymbol('proto.dapr.proto.placement.v1.PlacementOrder', null, global); @@ -456,8 +456,7 @@ proto.dapr.proto.placement.v1.PlacementTables.prototype.getEntriesMap = function */ proto.dapr.proto.placement.v1.PlacementTables.prototype.clearEntriesMap = function() { this.getEntriesMap().clear(); - return this; -}; + return this;}; /** @@ -688,8 +687,7 @@ proto.dapr.proto.placement.v1.PlacementTable.prototype.getHostsMap = function(op */ proto.dapr.proto.placement.v1.PlacementTable.prototype.clearHostsMap = function() { this.getHostsMap().clear(); - return this; -}; + return this;}; /** @@ -748,8 +746,7 @@ proto.dapr.proto.placement.v1.PlacementTable.prototype.getLoadMapMap = function( */ proto.dapr.proto.placement.v1.PlacementTable.prototype.clearLoadMapMap = function() { this.getLoadMapMap().clear(); - return this; -}; + return this;}; /** diff --git a/src/proto/dapr/proto/runtime/v1/appcallback_grpc_pb.js b/src/proto/dapr/proto/runtime/v1/appcallback_grpc_pb.js index 4b5633c5..bf46d6c8 100644 --- a/src/proto/dapr/proto/runtime/v1/appcallback_grpc_pb.js +++ b/src/proto/dapr/proto/runtime/v1/appcallback_grpc_pb.js @@ -245,7 +245,7 @@ onBindingEvent: { }, }; -exports.AppCallbackClient = grpc.makeGenericClientConstructor(AppCallbackService); +exports.AppCallbackClient = grpc.makeGenericClientConstructor(AppCallbackService, 'AppCallback'); // AppCallbackHealthCheck V1 is an optional extension to AppCallback V1 to implement // the HealthCheck method. var AppCallbackHealthCheckService = exports.AppCallbackHealthCheckService = { @@ -263,7 +263,7 @@ healthCheck: { }, }; -exports.AppCallbackHealthCheckClient = grpc.makeGenericClientConstructor(AppCallbackHealthCheckService); +exports.AppCallbackHealthCheckClient = grpc.makeGenericClientConstructor(AppCallbackHealthCheckService, 'AppCallbackHealthCheck'); // AppCallbackAlpha V1 is an optional extension to AppCallback V1 to opt // for Alpha RPCs. var AppCallbackAlphaService = exports.AppCallbackAlphaService = { @@ -293,4 +293,4 @@ onJobEventAlpha1: { }, }; -exports.AppCallbackAlphaClient = grpc.makeGenericClientConstructor(AppCallbackAlphaService); +exports.AppCallbackAlphaClient = grpc.makeGenericClientConstructor(AppCallbackAlphaService, 'AppCallbackAlpha'); diff --git a/src/proto/dapr/proto/runtime/v1/appcallback_pb.js b/src/proto/dapr/proto/runtime/v1/appcallback_pb.js index b14643a5..377ad889 100644 --- a/src/proto/dapr/proto/runtime/v1/appcallback_pb.js +++ b/src/proto/dapr/proto/runtime/v1/appcallback_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); goog.object.extend(proto, google_protobuf_any_pb); @@ -2099,8 +2099,7 @@ proto.dapr.proto.runtime.v1.TopicEventBulkRequestEntry.prototype.getMetadataMap */ proto.dapr.proto.runtime.v1.TopicEventBulkRequestEntry.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; @@ -2371,8 +2370,7 @@ proto.dapr.proto.runtime.v1.TopicEventBulkRequest.prototype.getMetadataMap = fun */ proto.dapr.proto.runtime.v1.TopicEventBulkRequest.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; /** @@ -2981,8 +2979,7 @@ proto.dapr.proto.runtime.v1.BindingEventRequest.prototype.getMetadataMap = funct */ proto.dapr.proto.runtime.v1.BindingEventRequest.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; @@ -3706,8 +3703,7 @@ proto.dapr.proto.runtime.v1.TopicSubscription.prototype.getMetadataMap = functio */ proto.dapr.proto.runtime.v1.TopicSubscription.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; /** diff --git a/src/proto/dapr/proto/runtime/v1/dapr.proto b/src/proto/dapr/proto/runtime/v1/dapr.proto index 8ecc3984..0130f38a 100644 --- a/src/proto/dapr/proto/runtime/v1/dapr.proto +++ b/src/proto/dapr/proto/runtime/v1/dapr.proto @@ -18,6 +18,7 @@ package dapr.proto.runtime.v1; import "google/protobuf/any.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; +import "google/protobuf/struct.proto"; import "dapr/proto/common/v1/common.proto"; import "dapr/proto/runtime/v1/appcallback.proto"; @@ -151,25 +152,39 @@ service Dapr { rpc SubtleVerifyAlpha1(SubtleVerifyRequest) returns (SubtleVerifyResponse); // Starts a new instance of a workflow - rpc StartWorkflowAlpha1 (StartWorkflowRequest) returns (StartWorkflowResponse) {} + rpc StartWorkflowAlpha1 (StartWorkflowRequest) returns (StartWorkflowResponse) { + option deprecated = true; + } // Gets details about a started workflow instance - rpc GetWorkflowAlpha1 (GetWorkflowRequest) returns (GetWorkflowResponse) {} + rpc GetWorkflowAlpha1 (GetWorkflowRequest) returns (GetWorkflowResponse) { + option deprecated = true; + } // Purge Workflow - rpc PurgeWorkflowAlpha1 (PurgeWorkflowRequest) returns (google.protobuf.Empty) {} + rpc PurgeWorkflowAlpha1 (PurgeWorkflowRequest) returns (google.protobuf.Empty) { + option deprecated = true; + } // Terminates a running workflow instance - rpc TerminateWorkflowAlpha1 (TerminateWorkflowRequest) returns (google.protobuf.Empty) {} + rpc TerminateWorkflowAlpha1 (TerminateWorkflowRequest) returns (google.protobuf.Empty) { + option deprecated = true; + } // Pauses a running workflow instance - rpc PauseWorkflowAlpha1 (PauseWorkflowRequest) returns (google.protobuf.Empty) {} + rpc PauseWorkflowAlpha1 (PauseWorkflowRequest) returns (google.protobuf.Empty) { + option deprecated = true; + } // Resumes a paused workflow instance - rpc ResumeWorkflowAlpha1 (ResumeWorkflowRequest) returns (google.protobuf.Empty) {} + rpc ResumeWorkflowAlpha1 (ResumeWorkflowRequest) returns (google.protobuf.Empty) { + option deprecated = true; + } // Raise an event to a running workflow instance - rpc RaiseEventWorkflowAlpha1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) {} + rpc RaiseEventWorkflowAlpha1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) { + option deprecated = true; + } // Starts a new instance of a workflow rpc StartWorkflowBeta1 (StartWorkflowRequest) returns (StartWorkflowResponse) {} @@ -191,6 +206,7 @@ service Dapr { // Raise an event to a running workflow instance rpc RaiseEventWorkflowBeta1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) {} + // Shutdown the sidecar rpc Shutdown (ShutdownRequest) returns (google.protobuf.Empty) {} @@ -202,6 +218,12 @@ service Dapr { // Delete a job rpc DeleteJobAlpha1(DeleteJobRequest) returns (DeleteJobResponse) {} + + // Converse with a LLM service + rpc ConverseAlpha1(ConversationRequest) returns (ConversationResponse) {} + + // Converse with a LLM service via alpha2 api + rpc ConverseAlpha2(ConversationRequestAlpha2) returns (ConversationResponseAlpha2) {} } // InvokeServiceRequest represents the request message for Service invocation. @@ -493,6 +515,7 @@ message InvokeBindingRequest { // // 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. @@ -675,7 +698,14 @@ message GetMetadataResponse { string runtime_version = 8 [json_name = "runtimeVersion"]; repeated string enabled_features = 9 [json_name = "enabledFeatures"]; ActorRuntime actor_runtime = 10 [json_name = "actorRuntime"]; - //TODO: Cassie: probably add scheduler runtime status + optional MetadataScheduler scheduler = 11 [json_name = "scheduler"]; +} + +// MetadataScheduler is a message that contains the list of addresses of the +// scheduler connections. +message MetadataScheduler { + // connected_addresses the list of addresses of the scheduler connections. + repeated string connected_addresses = 1; } message ActorRuntime { @@ -839,11 +869,11 @@ message TryLockRequest { // // 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 + // 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. + // 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. + // So this field in the request shouldn't be removed. string lock_owner = 3 [json_name = "lockOwner"]; // Required. The time before expiry.The time unit is second. @@ -880,7 +910,7 @@ message SubtleGetKeyRequest { // JSON (JSON Web Key) as string JSON = 1; } - + // Name of the component string component_name = 1 [json_name="componentName"]; // Name (or name/version) of the key to use in the key vault @@ -1062,7 +1092,7 @@ message EncryptRequestOptions { // 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. - bool omit_decryption_key_name = 11 [json_name="omitDecryptionKeyName"]; + bool omit_decryption_key_name = 11 [json_name="omitDecryptionKeyName"]; // 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). @@ -1205,20 +1235,20 @@ message Job { // // 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-7/sun-sat + // 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 * * * * + // 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 * * * * optional string schedule = 2 [json_name = "schedule"]; // repeats is the optional number of times in which the job should be @@ -1239,12 +1269,17 @@ message Job { // payload is the serialized job payload that will be sent to the recipient // when the job is triggered. google.protobuf.Any data = 6 [json_name = "data"]; + + // failure_policy is the optional policy for handling job failures. + optional common.v1.JobFailurePolicy failure_policy = 7 [json_name = "failurePolicy"]; } // ScheduleJobRequest is the message to create/schedule the job. message ScheduleJobRequest { // The job details. Job job = 1; + // If true, allows this job to overwrite an existing job with the same name. + bool overwrite = 2 [json_name = "overwrite"]; } // ScheduleJobResponse is the message response to create/schedule the job. @@ -1274,3 +1309,326 @@ message DeleteJobRequest { message DeleteJobResponse { // Empty } + +// ConversationRequest is the request object for Conversation. +message ConversationRequest { + option deprecated = true; + + // The name of Conversation component + string name = 1; + + // The ID of an existing chat (like in ChatGPT) + optional string contextID = 2; + + // Inputs for the conversation, support multiple input in one time. + repeated ConversationInput inputs = 3; + + // Parameters for all custom fields. + map parameters = 4; + + // The metadata passing to conversation components. + map metadata = 5; + + // Scrub PII data that comes back from the LLM + optional bool scrubPII = 6; + + // Temperature for the LLM to optimize for creativity or predictability + optional double temperature = 7; +} + +// ConversationRequestAlpha2 is the new request object for Conversation. +// Many of these fields are inspired by openai.ChatCompletionNewParams +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2106 +message ConversationRequestAlpha2 { + // The name of Conversation component + string name = 1; + + // The ID of an existing chat (like in ChatGPT) + optional string context_id = 2; + + // Inputs for the conversation, support multiple input in one time. + // This is the revamped conversation inputs better matching openai. + repeated ConversationInputAlpha2 inputs = 3; + + // Parameters for all custom fields. + map parameters = 4; + + // The metadata passing to conversation components. + map metadata = 5; + + // Scrub PII data that comes back from the LLM + optional bool scrub_pii = 6; + + // Temperature for the LLM to optimize for creativity or predictability + optional double temperature = 7; + + // Tools register the tools available to be used by the LLM during the conversation. + // These are sent on a per request basis. + // The tools available during the first round of the conversation + // may be different than tools specified later on. + repeated ConversationTools tools = 8; + + // Controls which (if any) tool is called by the model. + // `none` means the model will not call any tool and instead generates a message. + // `auto` means the model can pick between generating a message or calling one or more tools. + // Alternatively, a specific tool name may be used here, and casing/syntax must match on tool name. + // `none` is the default when no tools are present. + // `auto` is the default if tools are present. + // `required` requires one or more functions to be called. + // ref: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1976 + // ref: https://python.langchain.com/docs/how_to/tool_choice/ + optional string tool_choice = 9; + + /* TODO: fields to bring in from openai.ChatCompletionNewParams after Dapr 1.16. + Note: They can be within the other messages, not necessarily top level here. + MaxCompletionTokens: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2131 + Audio: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2186 + Modalities: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2215 + ReasoningEffort: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2224 + Stop: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2249 <----------------should we bring this in? + StreamOptions: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2251 + ResponseFormat: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2284 + */ +} + +// maintained for backwards compatibility +message ConversationInput { + option deprecated = true; + + // The content to send to the llm + string content = 1; + + // The role to set for the message + optional string role = 2; + + // Scrub PII data that goes into the LLM + optional bool scrubPII = 3; +} + +// directly inspired by openai.ChatCompletionNewParams +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2106 +message ConversationInputAlpha2 { + // The content to send to the llm + repeated ConversationMessage messages = 1; + + // Scrub PII data that goes into the LLM + optional bool scrub_pii = 2; +} + +// inspired by openai.ChatCompletionMessageParamUnion +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1449 +// The role field is inherent to the type of ConversationMessage, +// and is propagated in the backend according to the underlying LLM provider type. +message ConversationMessage { + oneof message_types { + ConversationMessageOfDeveloper of_developer = 1; + ConversationMessageOfSystem of_system = 2; + ConversationMessageOfUser of_user = 3; + ConversationMessageOfAssistant of_assistant = 4; + ConversationMessageOfTool of_tool = 5; + // Note: there could be a ConversationMessageOfFunction type here too, + // but that is deprecated in openai, so we will not support this. + } +} + +// inspired by openai.ChatCompletionDeveloperMessageParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1130 +// ConversationMessageOfDeveloper is intended to be the contents of a conversation message, +// as the role of a developer. +message ConversationMessageOfDeveloper { + // The name of the participant in the message. + optional string name = 1; + repeated ConversationMessageContent content = 2; +} + +// inspired by openai.ChatCompletionSystemMessageParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1842 +// ConversationMessageOfSystem is intended to be the contents of a conversation message, +// as the role of a system. +message ConversationMessageOfSystem { + optional string name = 1; + repeated ConversationMessageContent content = 2; +} + +// inspired by openai.ChatCompletionUserMessageParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2060C6-L2060C36 +// ConversationMessageOfUser is intended to be the contents of a conversation message, +// as the role of an end user. +message ConversationMessageOfUser { + optional string name = 1; + repeated ConversationMessageContent content = 2; +} + +// inspired by openai.ChatCompletionAssistantMessageParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L310 +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2060C6-L2060C36 +// ConversationMessageOfAssistant is intended to be the contents of a conversation message, +// as the role of an assistant. +message ConversationMessageOfAssistant { + optional string name = 1; + + // TODO: there is an audio field here to bring in when the time comes 1.17 or later. + + repeated ConversationMessageContent content = 2; + + // Tool calls generated by the model, such as function calls for the client to then make. + repeated ConversationToolCalls tool_calls = 3; + + // TODO: after 1.16 there is a refusal field that openai has here, + // but langchain does not have support for this yet, + // so we do not add to our api. + + // Note: There is a FunctionCall type too that is deprecated, + // so we are not bringing that to dapr. +} + +// inspired by openai.ChatCompletionToolMessageParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L2011 +// ConversationMessageOfTool is intended to be the contents of a conversation message, +// as the role of a tool. +message ConversationMessageOfTool { + // Tool ID is helpful for tracking tool history + optional string tool_id = 1; + + // Name of tool associated with the message + string name = 2; + + repeated ConversationMessageContent content = 3; + +} + +// inspired by openai.ChatCompletionMessageToolCallParam and openai.ChatCompletionMessageToolCall +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1669 +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1611 +// ConversationToolCalls is the tool call request sent from the llm to the client to then call to execute. +// This assumes that in our api if a client makes a request that would get a tool call response from the llm, +// that this client can also have the tool handy itself to execute it. +message ConversationToolCalls { + optional string id = 1; + oneof tool_types { + ConversationToolCallsOfFunction function = 2; + } +} + +// inspired by openai.ChatCompletionMessageToolCallFunctionParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1692 +message ConversationToolCallsOfFunction { + string name = 1; + // The arguments to call the function with, as generated by the model in JSON + // format. Note that the model does not always generate valid JSON, and may + // hallucinate parameters not defined by your function schema. Validate the + // arguments in your code before calling your function. + string arguments = 2; +} + +// inspired by openai.ChatCompletionContentPartTextParam & openai.ChatCompletionDeveloperMessageParamContentUnion +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1084 +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1154C6-L1154C53 +// Note: openai has this message be either a message of string or message of array type, +// so instead of this, we support that in one message type instead. +message ConversationMessageContent { + string text = 1; +} + +// ConversationResult is the result for one input. +message ConversationResult { + option deprecated = true; + + // Result for the one conversation input. + string result = 1; + // Parameters for all custom fields. + map parameters = 2; +} + +// inspired by openai.ChatCompletion +// ConversationResultAlpha2 is the result for one input. +message ConversationResultAlpha2 { + // Result for the conversation input. + repeated ConversationResultChoices choices = 1; + + /* TODO bring in for 1.17 based on openai + https://github.com/openai/openai-go/blob/main/chatcompletion.go#L166 + Usage https://github.com/openai/openai-go/blob/main/chatcompletion.go#L204 + + Bring in 1.16: + Created (timestamp): https://github.com/openai/openai-go/blob/main/chatcompletion.go#L173 + Model: https://github.com/openai/openai-go/blob/main/chatcompletion.go#L175 + */ +} + +// inspired by openai.ChatCompletionChoice +// based on https://github.com/openai/openai-go/blob/main/chatcompletion.go#L226 +message ConversationResultChoices { + // The reason the model stopped generating tokens. This will be `stop` if the model + // hit a natural stop point or a provided stop sequence, `length` if the maximum + // number of tokens specified in the request was reached, `content_filter` if + // content was omitted due to a flag from our content filters, `tool_calls` if the + // model called a tool. + // Any of "stop", "length", "tool_calls", "content_filter". + string finish_reason = 1; + + // The index of the choice in the list of choices. + int64 index = 2; + + ConversationResultMessage message = 3; +} + +// inspired by openai.ChatCompletionMessage +// based on https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1218C6-L1218C27 +message ConversationResultMessage { + // The contents of the message. + string content = 1; + // The tool calls generated by the model. + repeated ConversationToolCalls tool_calls = 2; + + // TODO: after 1.16 there is a refusal field that openai has here, + // but langchain does not have support for this yet, + // so we do not add to our api. +} + +// ConversationResponse is the response for Conversation. +message ConversationResponse { + option deprecated = true; + + // The ID of an existing chat (like in ChatGPT) + optional string contextID = 1; + + // An array of results. + repeated ConversationResult outputs = 2; +} + +// ConversationResponseAlpha2 is the Alpha2 response for Conversation. +message ConversationResponseAlpha2 { + // The ID of an existing chat (like in ChatGPT) + optional string context_id = 1; + + // An array of results. + repeated ConversationResultAlpha2 outputs = 2; +} + +// ConversationTools are the typed tools available to be called. +// inspired by openai.ChatCompletionToolParam +// https://github.com/openai/openai-go/blob/main/chatcompletion.go#L1950 +message ConversationTools { + oneof tool_types { + ConversationToolsFunction function = 1; + } +} + +// ConversationToolsFunction is the main tool type to be used in a conversation. +// inspired by openai.FunctionDefinitionParam +// https://pkg.go.dev/github.com/openai/openai-go/shared#FunctionDefinitionParam +message ConversationToolsFunction { + // The name of the function to be called. + string name = 1; + + // A description of what the function does, + // used by the model to choose when and how to call the function. + optional string description = 2; + + // The parameters the functions accepts, described as a JSON Schema object. + // See the [guide](https://platform.openai.com/docs/guides/function-calling) for examples, + // and the [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for documentation about the format. + // Omitting `parameters` defines a function with an empty parameter list. + google.protobuf.Struct parameters = 3; +} diff --git a/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.d.ts b/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.d.ts index 7c2e718d..7707d217 100644 --- a/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.d.ts +++ b/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.d.ts @@ -9,6 +9,7 @@ import * as dapr_proto_runtime_v1_dapr_pb from "../../../../dapr/proto/runtime/v import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb"; import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb"; import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb"; +import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb"; import * as dapr_proto_common_v1_common_pb from "../../../../dapr/proto/common/v1/common_pb"; import * as dapr_proto_runtime_v1_appcallback_pb from "../../../../dapr/proto/runtime/v1/appcallback_pb"; @@ -71,6 +72,8 @@ interface IDaprService extends grpc.ServiceDefinition { @@ -595,6 +598,24 @@ interface IDaprService_IDeleteJobAlpha1 extends grpc.MethodDefinition; responseDeserialize: grpc.deserialize; } +interface IDaprService_IConverseAlpha1 extends grpc.MethodDefinition { + path: "/dapr.proto.runtime.v1.Dapr/ConverseAlpha1"; + requestStream: false; + responseStream: false; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} +interface IDaprService_IConverseAlpha2 extends grpc.MethodDefinition { + path: "/dapr.proto.runtime.v1.Dapr/ConverseAlpha2"; + requestStream: false; + responseStream: false; + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} export const DaprService: IDaprService; @@ -657,6 +678,8 @@ export interface IDaprServer extends grpc.UntypedServiceImplementation { scheduleJobAlpha1: grpc.handleUnaryCall; getJobAlpha1: grpc.handleUnaryCall; deleteJobAlpha1: grpc.handleUnaryCall; + converseAlpha1: grpc.handleUnaryCall; + converseAlpha2: grpc.handleUnaryCall; } export interface IDaprClient { @@ -832,6 +855,12 @@ export interface IDaprClient { deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; + converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; + converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; + converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; } export class DaprClient extends grpc.Client implements IDaprClient { @@ -1005,4 +1034,10 @@ export class DaprClient extends grpc.Client implements IDaprClient { public deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; public deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; public deleteJobAlpha1(request: dapr_proto_runtime_v1_dapr_pb.DeleteJobRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.DeleteJobResponse) => void): grpc.ClientUnaryCall; + public converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + public converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + public converseAlpha1(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponse) => void): grpc.ClientUnaryCall; + public converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; + public converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; + public converseAlpha2(request: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2) => void): grpc.ClientUnaryCall; } diff --git a/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.js b/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.js index a4709e64..d4d506c8 100644 --- a/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.js +++ b/src/proto/dapr/proto/runtime/v1/dapr_grpc_pb.js @@ -19,6 +19,7 @@ var dapr_proto_runtime_v1_dapr_pb = require('../../../../dapr/proto/runtime/v1/d var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js'); var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js'); +var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js'); var dapr_proto_common_v1_common_pb = require('../../../../dapr/proto/common/v1/common_pb.js'); var dapr_proto_runtime_v1_appcallback_pb = require('../../../../dapr/proto/runtime/v1/appcallback_pb.js'); @@ -55,6 +56,50 @@ function deserialize_dapr_proto_runtime_v1_BulkPublishResponse(buffer_arg) { return dapr_proto_runtime_v1_dapr_pb.BulkPublishResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_dapr_proto_runtime_v1_ConversationRequest(arg) { + if (!(arg instanceof dapr_proto_runtime_v1_dapr_pb.ConversationRequest)) { + throw new Error('Expected argument of type dapr.proto.runtime.v1.ConversationRequest'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_runtime_v1_ConversationRequest(buffer_arg) { + return dapr_proto_runtime_v1_dapr_pb.ConversationRequest.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_runtime_v1_ConversationRequestAlpha2(arg) { + if (!(arg instanceof dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2)) { + throw new Error('Expected argument of type dapr.proto.runtime.v1.ConversationRequestAlpha2'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_runtime_v1_ConversationRequestAlpha2(buffer_arg) { + return dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_runtime_v1_ConversationResponse(arg) { + if (!(arg instanceof dapr_proto_runtime_v1_dapr_pb.ConversationResponse)) { + throw new Error('Expected argument of type dapr.proto.runtime.v1.ConversationResponse'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_runtime_v1_ConversationResponse(buffer_arg) { + return dapr_proto_runtime_v1_dapr_pb.ConversationResponse.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_dapr_proto_runtime_v1_ConversationResponseAlpha2(arg) { + if (!(arg instanceof dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2)) { + throw new Error('Expected argument of type dapr.proto.runtime.v1.ConversationResponseAlpha2'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_dapr_proto_runtime_v1_ConversationResponseAlpha2(buffer_arg) { + return dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_dapr_proto_runtime_v1_DecryptRequest(arg) { if (!(arg instanceof dapr_proto_runtime_v1_dapr_pb.DecryptRequest)) { throw new Error('Expected argument of type dapr.proto.runtime.v1.DecryptRequest'); @@ -1603,6 +1648,30 @@ deleteJobAlpha1: { responseSerialize: serialize_dapr_proto_runtime_v1_DeleteJobResponse, responseDeserialize: deserialize_dapr_proto_runtime_v1_DeleteJobResponse, }, + // Converse with a LLM service +converseAlpha1: { + path: '/dapr.proto.runtime.v1.Dapr/ConverseAlpha1', + requestStream: false, + responseStream: false, + requestType: dapr_proto_runtime_v1_dapr_pb.ConversationRequest, + responseType: dapr_proto_runtime_v1_dapr_pb.ConversationResponse, + requestSerialize: serialize_dapr_proto_runtime_v1_ConversationRequest, + requestDeserialize: deserialize_dapr_proto_runtime_v1_ConversationRequest, + responseSerialize: serialize_dapr_proto_runtime_v1_ConversationResponse, + responseDeserialize: deserialize_dapr_proto_runtime_v1_ConversationResponse, + }, + // Converse with a LLM service via alpha2 api +converseAlpha2: { + path: '/dapr.proto.runtime.v1.Dapr/ConverseAlpha2', + requestStream: false, + responseStream: false, + requestType: dapr_proto_runtime_v1_dapr_pb.ConversationRequestAlpha2, + responseType: dapr_proto_runtime_v1_dapr_pb.ConversationResponseAlpha2, + requestSerialize: serialize_dapr_proto_runtime_v1_ConversationRequestAlpha2, + requestDeserialize: deserialize_dapr_proto_runtime_v1_ConversationRequestAlpha2, + responseSerialize: serialize_dapr_proto_runtime_v1_ConversationResponseAlpha2, + responseDeserialize: deserialize_dapr_proto_runtime_v1_ConversationResponseAlpha2, + }, }; -exports.DaprClient = grpc.makeGenericClientConstructor(DaprService); +exports.DaprClient = grpc.makeGenericClientConstructor(DaprService, 'Dapr'); diff --git a/src/proto/dapr/proto/runtime/v1/dapr_pb.d.ts b/src/proto/dapr/proto/runtime/v1/dapr_pb.d.ts index 69ad0cf8..3de159a8 100644 --- a/src/proto/dapr/proto/runtime/v1/dapr_pb.d.ts +++ b/src/proto/dapr/proto/runtime/v1/dapr_pb.d.ts @@ -8,6 +8,7 @@ import * as jspb from "google-protobuf"; import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb"; import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb"; import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb"; +import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb"; import * as dapr_proto_common_v1_common_pb from "../../../../dapr/proto/common/v1/common_pb"; import * as dapr_proto_runtime_v1_appcallback_pb from "../../../../dapr/proto/runtime/v1/appcallback_pb"; @@ -1267,6 +1268,11 @@ export class GetMetadataResponse extends jspb.Message { getActorRuntime(): ActorRuntime | undefined; setActorRuntime(value?: ActorRuntime): GetMetadataResponse; + hasScheduler(): boolean; + clearScheduler(): void; + getScheduler(): MetadataScheduler | undefined; + setScheduler(value?: MetadataScheduler): GetMetadataResponse; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): GetMetadataResponse.AsObject; static toObject(includeInstance: boolean, msg: GetMetadataResponse): GetMetadataResponse.AsObject; @@ -1290,6 +1296,29 @@ export namespace GetMetadataResponse { runtimeVersion: string, enabledFeaturesList: Array, actorRuntime?: ActorRuntime.AsObject, + scheduler?: MetadataScheduler.AsObject, + } +} + +export class MetadataScheduler extends jspb.Message { + clearConnectedAddressesList(): void; + getConnectedAddressesList(): Array; + setConnectedAddressesList(value: Array): MetadataScheduler; + addConnectedAddresses(value: string, index?: number): string; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MetadataScheduler.AsObject; + static toObject(includeInstance: boolean, msg: MetadataScheduler): MetadataScheduler.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: MetadataScheduler, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MetadataScheduler; + static deserializeBinaryFromReader(message: MetadataScheduler, reader: jspb.BinaryReader): MetadataScheduler; +} + +export namespace MetadataScheduler { + export type AsObject = { + connectedAddressesList: Array, } } @@ -2722,6 +2751,11 @@ export class Job extends jspb.Message { getData(): google_protobuf_any_pb.Any | undefined; setData(value?: google_protobuf_any_pb.Any): Job; + hasFailurePolicy(): boolean; + clearFailurePolicy(): void; + getFailurePolicy(): dapr_proto_common_v1_common_pb.JobFailurePolicy | undefined; + setFailurePolicy(value?: dapr_proto_common_v1_common_pb.JobFailurePolicy): Job; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): Job.AsObject; static toObject(includeInstance: boolean, msg: Job): Job.AsObject; @@ -2740,6 +2774,7 @@ export namespace Job { dueTime?: string, ttl?: string, data?: google_protobuf_any_pb.Any.AsObject, + failurePolicy?: dapr_proto_common_v1_common_pb.JobFailurePolicy.AsObject, } } @@ -2749,6 +2784,8 @@ export class ScheduleJobRequest extends jspb.Message { clearJob(): void; getJob(): Job | undefined; setJob(value?: Job): ScheduleJobRequest; + getOverwrite(): boolean; + setOverwrite(value: boolean): ScheduleJobRequest; serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): ScheduleJobRequest.AsObject; @@ -2763,6 +2800,7 @@ export class ScheduleJobRequest extends jspb.Message { export namespace ScheduleJobRequest { export type AsObject = { job?: Job.AsObject, + overwrite: boolean, } } @@ -2863,6 +2901,690 @@ export namespace DeleteJobResponse { } } +export class ConversationRequest extends jspb.Message { + getName(): string; + setName(value: string): ConversationRequest; + + hasContextid(): boolean; + clearContextid(): void; + getContextid(): string | undefined; + setContextid(value: string): ConversationRequest; + clearInputsList(): void; + getInputsList(): Array; + setInputsList(value: Array): ConversationRequest; + addInputs(value?: ConversationInput, index?: number): ConversationInput; + + getParametersMap(): jspb.Map; + clearParametersMap(): void; + + getMetadataMap(): jspb.Map; + clearMetadataMap(): void; + + hasScrubpii(): boolean; + clearScrubpii(): void; + getScrubpii(): boolean | undefined; + setScrubpii(value: boolean): ConversationRequest; + + hasTemperature(): boolean; + clearTemperature(): void; + getTemperature(): number | undefined; + setTemperature(value: number): ConversationRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationRequest.AsObject; + static toObject(includeInstance: boolean, msg: ConversationRequest): ConversationRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationRequest; + static deserializeBinaryFromReader(message: ConversationRequest, reader: jspb.BinaryReader): ConversationRequest; +} + +export namespace ConversationRequest { + export type AsObject = { + name: string, + contextid?: string, + inputsList: Array, + + parametersMap: Array<[string, google_protobuf_any_pb.Any.AsObject]>, + + metadataMap: Array<[string, string]>, + scrubpii?: boolean, + temperature?: number, + } +} + +export class ConversationRequestAlpha2 extends jspb.Message { + getName(): string; + setName(value: string): ConversationRequestAlpha2; + + hasContextId(): boolean; + clearContextId(): void; + getContextId(): string | undefined; + setContextId(value: string): ConversationRequestAlpha2; + clearInputsList(): void; + getInputsList(): Array; + setInputsList(value: Array): ConversationRequestAlpha2; + addInputs(value?: ConversationInputAlpha2, index?: number): ConversationInputAlpha2; + + getParametersMap(): jspb.Map; + clearParametersMap(): void; + + getMetadataMap(): jspb.Map; + clearMetadataMap(): void; + + hasScrubPii(): boolean; + clearScrubPii(): void; + getScrubPii(): boolean | undefined; + setScrubPii(value: boolean): ConversationRequestAlpha2; + + hasTemperature(): boolean; + clearTemperature(): void; + getTemperature(): number | undefined; + setTemperature(value: number): ConversationRequestAlpha2; + clearToolsList(): void; + getToolsList(): Array; + setToolsList(value: Array): ConversationRequestAlpha2; + addTools(value?: ConversationTools, index?: number): ConversationTools; + + hasToolChoice(): boolean; + clearToolChoice(): void; + getToolChoice(): string | undefined; + setToolChoice(value: string): ConversationRequestAlpha2; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationRequestAlpha2.AsObject; + static toObject(includeInstance: boolean, msg: ConversationRequestAlpha2): ConversationRequestAlpha2.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationRequestAlpha2, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationRequestAlpha2; + static deserializeBinaryFromReader(message: ConversationRequestAlpha2, reader: jspb.BinaryReader): ConversationRequestAlpha2; +} + +export namespace ConversationRequestAlpha2 { + export type AsObject = { + name: string, + contextId?: string, + inputsList: Array, + + parametersMap: Array<[string, google_protobuf_any_pb.Any.AsObject]>, + + metadataMap: Array<[string, string]>, + scrubPii?: boolean, + temperature?: number, + toolsList: Array, + toolChoice?: string, + } +} + +export class ConversationInput extends jspb.Message { + getContent(): string; + setContent(value: string): ConversationInput; + + hasRole(): boolean; + clearRole(): void; + getRole(): string | undefined; + setRole(value: string): ConversationInput; + + hasScrubpii(): boolean; + clearScrubpii(): void; + getScrubpii(): boolean | undefined; + setScrubpii(value: boolean): ConversationInput; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationInput.AsObject; + static toObject(includeInstance: boolean, msg: ConversationInput): ConversationInput.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationInput, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationInput; + static deserializeBinaryFromReader(message: ConversationInput, reader: jspb.BinaryReader): ConversationInput; +} + +export namespace ConversationInput { + export type AsObject = { + content: string, + role?: string, + scrubpii?: boolean, + } +} + +export class ConversationInputAlpha2 extends jspb.Message { + clearMessagesList(): void; + getMessagesList(): Array; + setMessagesList(value: Array): ConversationInputAlpha2; + addMessages(value?: ConversationMessage, index?: number): ConversationMessage; + + hasScrubPii(): boolean; + clearScrubPii(): void; + getScrubPii(): boolean | undefined; + setScrubPii(value: boolean): ConversationInputAlpha2; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationInputAlpha2.AsObject; + static toObject(includeInstance: boolean, msg: ConversationInputAlpha2): ConversationInputAlpha2.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationInputAlpha2, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationInputAlpha2; + static deserializeBinaryFromReader(message: ConversationInputAlpha2, reader: jspb.BinaryReader): ConversationInputAlpha2; +} + +export namespace ConversationInputAlpha2 { + export type AsObject = { + messagesList: Array, + scrubPii?: boolean, + } +} + +export class ConversationMessage extends jspb.Message { + + hasOfDeveloper(): boolean; + clearOfDeveloper(): void; + getOfDeveloper(): ConversationMessageOfDeveloper | undefined; + setOfDeveloper(value?: ConversationMessageOfDeveloper): ConversationMessage; + + hasOfSystem(): boolean; + clearOfSystem(): void; + getOfSystem(): ConversationMessageOfSystem | undefined; + setOfSystem(value?: ConversationMessageOfSystem): ConversationMessage; + + hasOfUser(): boolean; + clearOfUser(): void; + getOfUser(): ConversationMessageOfUser | undefined; + setOfUser(value?: ConversationMessageOfUser): ConversationMessage; + + hasOfAssistant(): boolean; + clearOfAssistant(): void; + getOfAssistant(): ConversationMessageOfAssistant | undefined; + setOfAssistant(value?: ConversationMessageOfAssistant): ConversationMessage; + + hasOfTool(): boolean; + clearOfTool(): void; + getOfTool(): ConversationMessageOfTool | undefined; + setOfTool(value?: ConversationMessageOfTool): ConversationMessage; + + getMessageTypesCase(): ConversationMessage.MessageTypesCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessage.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessage): ConversationMessage.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessage, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessage; + static deserializeBinaryFromReader(message: ConversationMessage, reader: jspb.BinaryReader): ConversationMessage; +} + +export namespace ConversationMessage { + export type AsObject = { + ofDeveloper?: ConversationMessageOfDeveloper.AsObject, + ofSystem?: ConversationMessageOfSystem.AsObject, + ofUser?: ConversationMessageOfUser.AsObject, + ofAssistant?: ConversationMessageOfAssistant.AsObject, + ofTool?: ConversationMessageOfTool.AsObject, + } + + export enum MessageTypesCase { + MESSAGE_TYPES_NOT_SET = 0, + OF_DEVELOPER = 1, + OF_SYSTEM = 2, + OF_USER = 3, + OF_ASSISTANT = 4, + OF_TOOL = 5, + } + +} + +export class ConversationMessageOfDeveloper extends jspb.Message { + + hasName(): boolean; + clearName(): void; + getName(): string | undefined; + setName(value: string): ConversationMessageOfDeveloper; + clearContentList(): void; + getContentList(): Array; + setContentList(value: Array): ConversationMessageOfDeveloper; + addContent(value?: ConversationMessageContent, index?: number): ConversationMessageContent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageOfDeveloper.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageOfDeveloper): ConversationMessageOfDeveloper.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageOfDeveloper, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageOfDeveloper; + static deserializeBinaryFromReader(message: ConversationMessageOfDeveloper, reader: jspb.BinaryReader): ConversationMessageOfDeveloper; +} + +export namespace ConversationMessageOfDeveloper { + export type AsObject = { + name?: string, + contentList: Array, + } +} + +export class ConversationMessageOfSystem extends jspb.Message { + + hasName(): boolean; + clearName(): void; + getName(): string | undefined; + setName(value: string): ConversationMessageOfSystem; + clearContentList(): void; + getContentList(): Array; + setContentList(value: Array): ConversationMessageOfSystem; + addContent(value?: ConversationMessageContent, index?: number): ConversationMessageContent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageOfSystem.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageOfSystem): ConversationMessageOfSystem.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageOfSystem, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageOfSystem; + static deserializeBinaryFromReader(message: ConversationMessageOfSystem, reader: jspb.BinaryReader): ConversationMessageOfSystem; +} + +export namespace ConversationMessageOfSystem { + export type AsObject = { + name?: string, + contentList: Array, + } +} + +export class ConversationMessageOfUser extends jspb.Message { + + hasName(): boolean; + clearName(): void; + getName(): string | undefined; + setName(value: string): ConversationMessageOfUser; + clearContentList(): void; + getContentList(): Array; + setContentList(value: Array): ConversationMessageOfUser; + addContent(value?: ConversationMessageContent, index?: number): ConversationMessageContent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageOfUser.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageOfUser): ConversationMessageOfUser.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageOfUser, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageOfUser; + static deserializeBinaryFromReader(message: ConversationMessageOfUser, reader: jspb.BinaryReader): ConversationMessageOfUser; +} + +export namespace ConversationMessageOfUser { + export type AsObject = { + name?: string, + contentList: Array, + } +} + +export class ConversationMessageOfAssistant extends jspb.Message { + + hasName(): boolean; + clearName(): void; + getName(): string | undefined; + setName(value: string): ConversationMessageOfAssistant; + clearContentList(): void; + getContentList(): Array; + setContentList(value: Array): ConversationMessageOfAssistant; + addContent(value?: ConversationMessageContent, index?: number): ConversationMessageContent; + clearToolCallsList(): void; + getToolCallsList(): Array; + setToolCallsList(value: Array): ConversationMessageOfAssistant; + addToolCalls(value?: ConversationToolCalls, index?: number): ConversationToolCalls; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageOfAssistant.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageOfAssistant): ConversationMessageOfAssistant.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageOfAssistant, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageOfAssistant; + static deserializeBinaryFromReader(message: ConversationMessageOfAssistant, reader: jspb.BinaryReader): ConversationMessageOfAssistant; +} + +export namespace ConversationMessageOfAssistant { + export type AsObject = { + name?: string, + contentList: Array, + toolCallsList: Array, + } +} + +export class ConversationMessageOfTool extends jspb.Message { + + hasToolId(): boolean; + clearToolId(): void; + getToolId(): string | undefined; + setToolId(value: string): ConversationMessageOfTool; + getName(): string; + setName(value: string): ConversationMessageOfTool; + clearContentList(): void; + getContentList(): Array; + setContentList(value: Array): ConversationMessageOfTool; + addContent(value?: ConversationMessageContent, index?: number): ConversationMessageContent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageOfTool.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageOfTool): ConversationMessageOfTool.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageOfTool, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageOfTool; + static deserializeBinaryFromReader(message: ConversationMessageOfTool, reader: jspb.BinaryReader): ConversationMessageOfTool; +} + +export namespace ConversationMessageOfTool { + export type AsObject = { + toolId?: string, + name: string, + contentList: Array, + } +} + +export class ConversationToolCalls extends jspb.Message { + + hasId(): boolean; + clearId(): void; + getId(): string | undefined; + setId(value: string): ConversationToolCalls; + + hasFunction(): boolean; + clearFunction(): void; + getFunction(): ConversationToolCallsOfFunction | undefined; + setFunction(value?: ConversationToolCallsOfFunction): ConversationToolCalls; + + getToolTypesCase(): ConversationToolCalls.ToolTypesCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationToolCalls.AsObject; + static toObject(includeInstance: boolean, msg: ConversationToolCalls): ConversationToolCalls.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationToolCalls, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationToolCalls; + static deserializeBinaryFromReader(message: ConversationToolCalls, reader: jspb.BinaryReader): ConversationToolCalls; +} + +export namespace ConversationToolCalls { + export type AsObject = { + id?: string, + pb_function?: ConversationToolCallsOfFunction.AsObject, + } + + export enum ToolTypesCase { + TOOL_TYPES_NOT_SET = 0, + FUNCTION = 2, + } + +} + +export class ConversationToolCallsOfFunction extends jspb.Message { + getName(): string; + setName(value: string): ConversationToolCallsOfFunction; + getArguments(): string; + setArguments(value: string): ConversationToolCallsOfFunction; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationToolCallsOfFunction.AsObject; + static toObject(includeInstance: boolean, msg: ConversationToolCallsOfFunction): ConversationToolCallsOfFunction.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationToolCallsOfFunction, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationToolCallsOfFunction; + static deserializeBinaryFromReader(message: ConversationToolCallsOfFunction, reader: jspb.BinaryReader): ConversationToolCallsOfFunction; +} + +export namespace ConversationToolCallsOfFunction { + export type AsObject = { + name: string, + arguments: string, + } +} + +export class ConversationMessageContent extends jspb.Message { + getText(): string; + setText(value: string): ConversationMessageContent; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationMessageContent.AsObject; + static toObject(includeInstance: boolean, msg: ConversationMessageContent): ConversationMessageContent.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationMessageContent, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationMessageContent; + static deserializeBinaryFromReader(message: ConversationMessageContent, reader: jspb.BinaryReader): ConversationMessageContent; +} + +export namespace ConversationMessageContent { + export type AsObject = { + text: string, + } +} + +export class ConversationResult extends jspb.Message { + getResult(): string; + setResult(value: string): ConversationResult; + + getParametersMap(): jspb.Map; + clearParametersMap(): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResult.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResult): ConversationResult.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResult, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResult; + static deserializeBinaryFromReader(message: ConversationResult, reader: jspb.BinaryReader): ConversationResult; +} + +export namespace ConversationResult { + export type AsObject = { + result: string, + + parametersMap: Array<[string, google_protobuf_any_pb.Any.AsObject]>, + } +} + +export class ConversationResultAlpha2 extends jspb.Message { + clearChoicesList(): void; + getChoicesList(): Array; + setChoicesList(value: Array): ConversationResultAlpha2; + addChoices(value?: ConversationResultChoices, index?: number): ConversationResultChoices; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResultAlpha2.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResultAlpha2): ConversationResultAlpha2.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResultAlpha2, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResultAlpha2; + static deserializeBinaryFromReader(message: ConversationResultAlpha2, reader: jspb.BinaryReader): ConversationResultAlpha2; +} + +export namespace ConversationResultAlpha2 { + export type AsObject = { + choicesList: Array, + } +} + +export class ConversationResultChoices extends jspb.Message { + getFinishReason(): string; + setFinishReason(value: string): ConversationResultChoices; + getIndex(): number; + setIndex(value: number): ConversationResultChoices; + + hasMessage(): boolean; + clearMessage(): void; + getMessage(): ConversationResultMessage | undefined; + setMessage(value?: ConversationResultMessage): ConversationResultChoices; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResultChoices.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResultChoices): ConversationResultChoices.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResultChoices, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResultChoices; + static deserializeBinaryFromReader(message: ConversationResultChoices, reader: jspb.BinaryReader): ConversationResultChoices; +} + +export namespace ConversationResultChoices { + export type AsObject = { + finishReason: string, + index: number, + message?: ConversationResultMessage.AsObject, + } +} + +export class ConversationResultMessage extends jspb.Message { + getContent(): string; + setContent(value: string): ConversationResultMessage; + clearToolCallsList(): void; + getToolCallsList(): Array; + setToolCallsList(value: Array): ConversationResultMessage; + addToolCalls(value?: ConversationToolCalls, index?: number): ConversationToolCalls; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResultMessage.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResultMessage): ConversationResultMessage.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResultMessage, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResultMessage; + static deserializeBinaryFromReader(message: ConversationResultMessage, reader: jspb.BinaryReader): ConversationResultMessage; +} + +export namespace ConversationResultMessage { + export type AsObject = { + content: string, + toolCallsList: Array, + } +} + +export class ConversationResponse extends jspb.Message { + + hasContextid(): boolean; + clearContextid(): void; + getContextid(): string | undefined; + setContextid(value: string): ConversationResponse; + clearOutputsList(): void; + getOutputsList(): Array; + setOutputsList(value: Array): ConversationResponse; + addOutputs(value?: ConversationResult, index?: number): ConversationResult; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResponse.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResponse): ConversationResponse.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResponse; + static deserializeBinaryFromReader(message: ConversationResponse, reader: jspb.BinaryReader): ConversationResponse; +} + +export namespace ConversationResponse { + export type AsObject = { + contextid?: string, + outputsList: Array, + } +} + +export class ConversationResponseAlpha2 extends jspb.Message { + + hasContextId(): boolean; + clearContextId(): void; + getContextId(): string | undefined; + setContextId(value: string): ConversationResponseAlpha2; + clearOutputsList(): void; + getOutputsList(): Array; + setOutputsList(value: Array): ConversationResponseAlpha2; + addOutputs(value?: ConversationResultAlpha2, index?: number): ConversationResultAlpha2; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationResponseAlpha2.AsObject; + static toObject(includeInstance: boolean, msg: ConversationResponseAlpha2): ConversationResponseAlpha2.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationResponseAlpha2, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationResponseAlpha2; + static deserializeBinaryFromReader(message: ConversationResponseAlpha2, reader: jspb.BinaryReader): ConversationResponseAlpha2; +} + +export namespace ConversationResponseAlpha2 { + export type AsObject = { + contextId?: string, + outputsList: Array, + } +} + +export class ConversationTools extends jspb.Message { + + hasFunction(): boolean; + clearFunction(): void; + getFunction(): ConversationToolsFunction | undefined; + setFunction(value?: ConversationToolsFunction): ConversationTools; + + getToolTypesCase(): ConversationTools.ToolTypesCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationTools.AsObject; + static toObject(includeInstance: boolean, msg: ConversationTools): ConversationTools.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationTools, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationTools; + static deserializeBinaryFromReader(message: ConversationTools, reader: jspb.BinaryReader): ConversationTools; +} + +export namespace ConversationTools { + export type AsObject = { + pb_function?: ConversationToolsFunction.AsObject, + } + + export enum ToolTypesCase { + TOOL_TYPES_NOT_SET = 0, + FUNCTION = 1, + } + +} + +export class ConversationToolsFunction extends jspb.Message { + getName(): string; + setName(value: string): ConversationToolsFunction; + + hasDescription(): boolean; + clearDescription(): void; + getDescription(): string | undefined; + setDescription(value: string): ConversationToolsFunction; + + hasParameters(): boolean; + clearParameters(): void; + getParameters(): google_protobuf_struct_pb.Struct | undefined; + setParameters(value?: google_protobuf_struct_pb.Struct): ConversationToolsFunction; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ConversationToolsFunction.AsObject; + static toObject(includeInstance: boolean, msg: ConversationToolsFunction): ConversationToolsFunction.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ConversationToolsFunction, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ConversationToolsFunction; + static deserializeBinaryFromReader(message: ConversationToolsFunction, reader: jspb.BinaryReader): ConversationToolsFunction; +} + +export namespace ConversationToolsFunction { + export type AsObject = { + name: string, + description?: string, + parameters?: google_protobuf_struct_pb.Struct.AsObject, + } +} + export enum PubsubSubscriptionType { UNKNOWN = 0, DECLARATIVE = 1, diff --git a/src/proto/dapr/proto/runtime/v1/dapr_pb.js b/src/proto/dapr/proto/runtime/v1/dapr_pb.js index b995caf1..803c381f 100644 --- a/src/proto/dapr/proto/runtime/v1/dapr_pb.js +++ b/src/proto/dapr/proto/runtime/v1/dapr_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_any_pb = require('google-protobuf/google/protobuf/any_pb.js'); goog.object.extend(proto, google_protobuf_any_pb); @@ -27,6 +27,8 @@ var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb goog.object.extend(proto, google_protobuf_empty_pb); var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js'); goog.object.extend(proto, google_protobuf_timestamp_pb); +var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js'); +goog.object.extend(proto, google_protobuf_struct_pb); var dapr_proto_common_v1_common_pb = require('../../../../dapr/proto/common/v1/common_pb.js'); goog.object.extend(proto, dapr_proto_common_v1_common_pb); var dapr_proto_runtime_v1_appcallback_pb = require('../../../../dapr/proto/runtime/v1/appcallback_pb.js'); @@ -41,6 +43,30 @@ goog.exportSymbol('proto.dapr.proto.runtime.v1.BulkPublishRequestEntry', null, g goog.exportSymbol('proto.dapr.proto.runtime.v1.BulkPublishResponse', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.BulkStateItem', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationInput', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationInputAlpha2', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessage', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessage.MessageTypesCase', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageContent', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageOfSystem', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageOfTool', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationMessageOfUser', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationRequest', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationRequestAlpha2', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResponse', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResponseAlpha2', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResult', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResultAlpha2', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResultChoices', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationResultMessage', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationToolCalls', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationToolCalls.ToolTypesCase', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationTools', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationTools.ToolTypesCase', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.ConversationToolsFunction', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.DecryptRequest', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.DecryptRequestOptions', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.DecryptResponse', null, global); @@ -78,6 +104,7 @@ goog.exportSymbol('proto.dapr.proto.runtime.v1.InvokeBindingResponse', null, glo goog.exportSymbol('proto.dapr.proto.runtime.v1.InvokeServiceRequest', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.Job', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint', null, global); +goog.exportSymbol('proto.dapr.proto.runtime.v1.MetadataScheduler', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.PauseWorkflowRequest', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.PublishEventRequest', null, global); goog.exportSymbol('proto.dapr.proto.runtime.v1.PubsubSubscription', null, global); @@ -1040,6 +1067,27 @@ if (goog.DEBUG && !COMPILED) { */ proto.dapr.proto.runtime.v1.GetMetadataResponse.displayName = 'proto.dapr.proto.runtime.v1.GetMetadataResponse'; } +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.MetadataScheduler = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.MetadataScheduler.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.MetadataScheduler, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.MetadataScheduler.displayName = 'proto.dapr.proto.runtime.v1.MetadataScheduler'; +} /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -2237,175 +2285,4643 @@ if (goog.DEBUG && !COMPILED) { */ proto.dapr.proto.runtime.v1.DeleteJobResponse.displayName = 'proto.dapr.proto.runtime.v1.DeleteJobResponse'; } - - - -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.InvokeServiceRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationRequest.repeatedFields_, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationRequest.displayName = 'proto.dapr.proto.runtime.v1.ConversationRequest'; +} /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.toObject = function(includeInstance, msg) { - var f, obj = { - id: jspb.Message.getFieldWithDefault(msg, 1, ""), - message: (f = msg.getMessage()) && dapr_proto_common_v1_common_pb.InvokeRequest.toObject(includeInstance, f) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2 = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.repeatedFields_, null); }; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationRequestAlpha2, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.displayName = 'proto.dapr.proto.runtime.v1.ConversationRequestAlpha2'; } - - /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.InvokeServiceRequest; - return proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.ConversationInput = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationInput, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationInput.displayName = 'proto.dapr.proto.runtime.v1.ConversationInput'; +} /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setId(value); - break; - case 3: - var value = new dapr_proto_common_v1_common_pb.InvokeRequest; - reader.readMessage(value,dapr_proto_common_v1_common_pb.InvokeRequest.deserializeBinaryFromReader); - msg.setMessage(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; +proto.dapr.proto.runtime.v1.ConversationInputAlpha2 = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationInputAlpha2.repeatedFields_, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationInputAlpha2, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationInputAlpha2.displayName = 'proto.dapr.proto.runtime.v1.ConversationInputAlpha2'; +} /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.InvokeServiceRequest.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationMessage = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessage, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessage.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessage'; +} /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getId(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getMessage(); - if (f != null) { - writer.writeMessage( - 3, - f, - dapr_proto_common_v1_common_pb.InvokeRequest.serializeBinaryToWriter - ); - } +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.repeatedFields_, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper'; +} /** - * optional string id = 1; - * @return {string} + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.getId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.repeatedFields_, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageOfSystem, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageOfSystem'; +} /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.setId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfUser = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationMessageOfUser.repeatedFields_, null); }; - - +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageOfUser, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageOfUser.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageOfUser'; +} /** - * optional dapr.proto.common.v1.InvokeRequest message = 3; - * @return {?proto.dapr.proto.common.v1.InvokeRequest} - */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.getMessage = function() { - return /** @type{?proto.dapr.proto.common.v1.InvokeRequest} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.InvokeRequest, 3)); -}; - + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationMessageOfTool.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageOfTool, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageOfTool.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageOfTool'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationToolCalls = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.dapr.proto.runtime.v1.ConversationToolCalls.oneofGroups_); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationToolCalls, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationToolCalls.displayName = 'proto.dapr.proto.runtime.v1.ConversationToolCalls'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.displayName = 'proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationMessageContent = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationMessageContent, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationMessageContent.displayName = 'proto.dapr.proto.runtime.v1.ConversationMessageContent'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResult = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResult, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResult.displayName = 'proto.dapr.proto.runtime.v1.ConversationResult'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResultAlpha2 = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationResultAlpha2.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResultAlpha2, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResultAlpha2.displayName = 'proto.dapr.proto.runtime.v1.ConversationResultAlpha2'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResultChoices = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResultChoices, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResultChoices.displayName = 'proto.dapr.proto.runtime.v1.ConversationResultChoices'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResultMessage = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationResultMessage.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResultMessage, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResultMessage.displayName = 'proto.dapr.proto.runtime.v1.ConversationResultMessage'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationResponse.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResponse.displayName = 'proto.dapr.proto.runtime.v1.ConversationResponse'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2 = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.repeatedFields_, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationResponseAlpha2, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.displayName = 'proto.dapr.proto.runtime.v1.ConversationResponseAlpha2'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationTools = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.dapr.proto.runtime.v1.ConversationTools.oneofGroups_); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationTools, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationTools.displayName = 'proto.dapr.proto.runtime.v1.ConversationTools'; +} +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.dapr.proto.runtime.v1.ConversationToolsFunction = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.dapr.proto.runtime.v1.ConversationToolsFunction, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.dapr.proto.runtime.v1.ConversationToolsFunction.displayName = 'proto.dapr.proto.runtime.v1.ConversationToolsFunction'; +} + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.InvokeServiceRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.toObject = function(includeInstance, msg) { + var f, obj = { + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + message: (f = msg.getMessage()) && dapr_proto_common_v1_common_pb.InvokeRequest.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.InvokeServiceRequest; + return proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + case 3: + var value = new dapr_proto_common_v1_common_pb.InvokeRequest; + reader.readMessage(value,dapr_proto_common_v1_common_pb.InvokeRequest.deserializeBinaryFromReader); + msg.setMessage(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.InvokeServiceRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getMessage(); + if (f != null) { + writer.writeMessage( + 3, + f, + dapr_proto_common_v1_common_pb.InvokeRequest.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string id = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional dapr.proto.common.v1.InvokeRequest message = 3; + * @return {?proto.dapr.proto.common.v1.InvokeRequest} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.getMessage = function() { + return /** @type{?proto.dapr.proto.common.v1.InvokeRequest} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.InvokeRequest, 3)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.InvokeRequest|undefined} value + * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this +*/ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.setMessage = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.clearMessage = function() { + return this.setMessage(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.hasMessage = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + key: jspb.Message.getFieldWithDefault(msg, 2, ""), + consistency: jspb.Message.getFieldWithDefault(msg, 3, 0), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetStateRequest; + return proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 3: + var value = /** @type {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} */ (reader.readEnum()); + msg.setConsistency(value); + break; + case 4: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getConsistency(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string key = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional dapr.proto.common.v1.StateOptions.StateConsistency consistency = 3; + * @return {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getConsistency = function() { + return /** @type {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} value + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setConsistency = function(value) { + return jspb.Message.setProto3EnumField(this, 3, value); +}; + + +/** + * map metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetStateRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetBulkStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, + parallelism: jspb.Message.getFieldWithDefault(msg, 3, 0), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetBulkStateRequest; + return proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.addKeys(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setParallelism(value); + break; + case 4: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetBulkStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getKeysList(); + if (f.length > 0) { + writer.writeRepeatedString( + 2, + f + ); + } + f = message.getParallelism(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated string keys = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getKeysList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setKeysList = function(value) { + return jspb.Message.setField(this, 2, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.addKeys = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 2, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.clearKeysList = function() { + return this.setKeysList([]); +}; + + +/** + * optional int32 parallelism = 3; + * @return {number} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getParallelism = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setParallelism = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * map metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetBulkStateResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.toObject = function(includeInstance, msg) { + var f, obj = { + itemsList: jspb.Message.toObjectList(msg.getItemsList(), + proto.dapr.proto.runtime.v1.BulkStateItem.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetBulkStateResponse; + return proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.runtime.v1.BulkStateItem; + reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader); + msg.addItems(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetBulkStateResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getItemsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated BulkStateItem items = 1; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.getItemsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkStateItem, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.setItemsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.BulkStateItem=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.addItems = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.BulkStateItem, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.clearItemsList = function() { + return this.setItemsList([]); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.BulkStateItem.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkStateItem.toObject = function(includeInstance, msg) { + var f, obj = { + key: jspb.Message.getFieldWithDefault(msg, 1, ""), + data: msg.getData_asB64(), + etag: jspb.Message.getFieldWithDefault(msg, 3, ""), + error: jspb.Message.getFieldWithDefault(msg, 4, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.BulkStateItem; + return proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setEtag(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setError(value); + break; + case 5: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getEtag(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getError(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string key = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes data = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes data = 2; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string etag = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getEtag = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setEtag = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string error = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getError = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setError = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + */ +proto.dapr.proto.runtime.v1.BulkStateItem.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetStateResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetStateResponse.toObject = function(includeInstance, msg) { + var f, obj = { + data: msg.getData_asB64(), + etag: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetStateResponse; + return proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setEtag(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetStateResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetStateResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getEtag(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional bytes data = 1; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes data = 1; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional string etag = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getEtag = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.setEtag = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetStateResponse.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DeleteStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + key: jspb.Message.getFieldWithDefault(msg, 2, ""), + etag: (f = msg.getEtag()) && dapr_proto_common_v1_common_pb.Etag.toObject(includeInstance, f), + options: (f = msg.getOptions()) && dapr_proto_common_v1_common_pb.StateOptions.toObject(includeInstance, f), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.DeleteStateRequest; + return proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 3: + var value = new dapr_proto_common_v1_common_pb.Etag; + reader.readMessage(value,dapr_proto_common_v1_common_pb.Etag.deserializeBinaryFromReader); + msg.setEtag(value); + break; + case 4: + var value = new dapr_proto_common_v1_common_pb.StateOptions; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StateOptions.deserializeBinaryFromReader); + msg.setOptions(value); + break; + case 5: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.DeleteStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getEtag(); + if (f != null) { + writer.writeMessage( + 3, + f, + dapr_proto_common_v1_common_pb.Etag.serializeBinaryToWriter + ); + } + f = message.getOptions(); + if (f != null) { + writer.writeMessage( + 4, + f, + dapr_proto_common_v1_common_pb.StateOptions.serializeBinaryToWriter + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string key = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional dapr.proto.common.v1.Etag etag = 3; + * @return {?proto.dapr.proto.common.v1.Etag} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getEtag = function() { + return /** @type{?proto.dapr.proto.common.v1.Etag} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.Etag, 3)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.Etag|undefined} value + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this +*/ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setEtag = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearEtag = function() { + return this.setEtag(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.hasEtag = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * optional dapr.proto.common.v1.StateOptions options = 4; + * @return {?proto.dapr.proto.common.v1.StateOptions} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getOptions = function() { + return /** @type{?proto.dapr.proto.common.v1.StateOptions} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StateOptions, 4)); +}; + + +/** + * @param {?proto.dapr.proto.common.v1.StateOptions|undefined} value + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this +*/ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setOptions = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearOptions = function() { + return this.setOptions(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.hasOptions = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + statesList: jspb.Message.toObjectList(msg.getStatesList(), + dapr_proto_common_v1_common_pb.StateItem.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.DeleteBulkStateRequest; + return proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = new dapr_proto_common_v1_common_pb.StateItem; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StateItem.deserializeBinaryFromReader); + msg.addStates(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getStatesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + dapr_proto_common_v1_common_pb.StateItem.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated dapr.proto.common.v1.StateItem states = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.getStatesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this +*/ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.setStatesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.common.v1.StateItem=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.common.v1.StateItem} + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.addStates = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.common.v1.StateItem, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.clearStatesList = function() { + return this.setStatesList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SaveStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + statesList: jspb.Message.toObjectList(msg.getStatesList(), + dapr_proto_common_v1_common_pb.StateItem.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SaveStateRequest; + return proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = new dapr_proto_common_v1_common_pb.StateItem; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StateItem.deserializeBinaryFromReader); + msg.addStates(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SaveStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getStatesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + dapr_proto_common_v1_common_pb.StateItem.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated dapr.proto.common.v1.StateItem states = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.getStatesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this +*/ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.setStatesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.common.v1.StateItem=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.common.v1.StateItem} + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.addStates = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.common.v1.StateItem, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.clearStatesList = function() { + return this.setStatesList([]); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.QueryStateRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + query: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.QueryStateRequest; + return proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setQuery(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.QueryStateRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getQuery(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string query = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getQuery = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.setQuery = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.QueryStateItem.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateItem.toObject = function(includeInstance, msg) { + var f, obj = { + key: jspb.Message.getFieldWithDefault(msg, 1, ""), + data: msg.getData_asB64(), + etag: jspb.Message.getFieldWithDefault(msg, 3, ""), + error: jspb.Message.getFieldWithDefault(msg, 4, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.QueryStateItem; + return proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setEtag(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setError(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getEtag(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getError(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } +}; + + +/** + * optional string key = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes data = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes data = 2; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string etag = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getEtag = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setEtag = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string error = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getError = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setError = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.QueryStateResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.toObject = function(includeInstance, msg) { + var f, obj = { + resultsList: jspb.Message.toObjectList(msg.getResultsList(), + proto.dapr.proto.runtime.v1.QueryStateItem.toObject, includeInstance), + token: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.QueryStateResponse; + return proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.runtime.v1.QueryStateItem; + reader.readMessage(value,proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader); + msg.addResults(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setToken(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.QueryStateResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getResultsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter + ); + } + f = message.getToken(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * repeated QueryStateItem results = 1; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getResultsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.QueryStateItem, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this +*/ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.setResultsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.QueryStateItem=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.addResults = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.QueryStateItem, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.clearResultsList = function() { + return this.setResultsList([]); +}; + + +/** + * optional string token = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getToken = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.setToken = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PublishEventRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.toObject = function(includeInstance, msg) { + var f, obj = { + pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), + topic: jspb.Message.getFieldWithDefault(msg, 2, ""), + data: msg.getData_asB64(), + dataContentType: jspb.Message.getFieldWithDefault(msg, 4, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.PublishEventRequest; + return proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setPubsubName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTopic(value); + break; + case 3: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setDataContentType(value); + break; + case 5: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.PublishEventRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPubsubName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getTopic(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 3, + f + ); + } + f = message.getDataContentType(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string pubsub_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getPubsubName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setPubsubName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string topic = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setTopic = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional bytes data = 3; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * optional bytes data = 3; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 3; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 3, value); +}; + + +/** + * optional string data_content_type = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getDataContentType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setDataContentType = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + */ +proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.BulkPublishRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.toObject = function(includeInstance, msg) { + var f, obj = { + pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), + topic: jspb.Message.getFieldWithDefault(msg, 2, ""), + entriesList: jspb.Message.toObjectList(msg.getEntriesList(), + proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject, includeInstance), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.BulkPublishRequest; + return proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setPubsubName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTopic(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.BulkPublishRequestEntry; + reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader); + msg.addEntries(value); + break; + case 4: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.BulkPublishRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPubsubName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getTopic(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getEntriesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string pubsub_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getPubsubName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setPubsubName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string topic = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setTopic = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * repeated BulkPublishRequestEntry entries = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getEntriesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkPublishRequestEntry, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this +*/ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setEntriesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.addEntries = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.BulkPublishRequestEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.clearEntriesList = function() { + return this.setEntriesList([]); +}; + + +/** + * map metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject = function(includeInstance, msg) { + var f, obj = { + entryId: jspb.Message.getFieldWithDefault(msg, 1, ""), + event: msg.getEvent_asB64(), + contentType: jspb.Message.getFieldWithDefault(msg, 3, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.BulkPublishRequestEntry; + return proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setEntryId(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setEvent(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setContentType(value); + break; + case 4: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getEntryId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getEvent_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getContentType(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } +}; + + +/** + * optional string entry_id = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEntryId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setEntryId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes event = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes event = 2; + * This is a type-conversion wrapper around `getEvent()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getEvent())); +}; + + +/** + * optional bytes event = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getEvent()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getEvent())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setEvent = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string content_type = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getContentType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setContentType = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * map metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.BulkPublishResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.toObject = function(includeInstance, msg) { + var f, obj = { + failedentriesList: jspb.Message.toObjectList(msg.getFailedentriesList(), + proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.BulkPublishResponse; + return proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry; + reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader); + msg.addFailedentries(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.BulkPublishResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getFailedentriesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated BulkPublishResponseFailedEntry failedEntries = 1; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.getFailedentriesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} returns this +*/ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.setFailedentriesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.addFailedentries = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.clearFailedentriesList = function() { + return this.setFailedentriesList([]); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject = function(includeInstance, msg) { + var f, obj = { + entryId: jspb.Message.getFieldWithDefault(msg, 1, ""), + error: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry; + return proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setEntryId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setError(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getEntryId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getError(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string entry_id = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.getEntryId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.setEntryId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string error = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.getError = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} returns this + */ +proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.setError = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_ = [[1,2]]; + +/** + * @enum {number} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase = { + SUBSCRIBE_TOPIC_EVENTS_REQUEST_TYPE_NOT_SET: 0, + INITIAL_REQUEST: 1, + EVENT_PROCESSED: 2 +}; + +/** + * @return {proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getSubscribeTopicEventsRequestTypeCase = function() { + return /** @type {proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0])); +}; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.toObject = function(includeInstance, msg) { + var f, obj = { + initialRequest: (f = msg.getInitialRequest()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject(includeInstance, f), + eventProcessed: (f = msg.getEventProcessed()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1; + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1; + reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader); + msg.setInitialRequest(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1; + reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader); + msg.setEventProcessed(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getInitialRequest(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter + ); + } + f = message.getEventProcessed(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter + ); + } +}; + + +/** + * optional SubscribeTopicEventsRequestInitialAlpha1 initial_request = 1; + * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getInitialRequest = function() { + return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1, 1)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1|undefined} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this +*/ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.setInitialRequest = function(value) { + return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.clearInitialRequest = function() { + return this.setInitialRequest(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.hasInitialRequest = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional SubscribeTopicEventsRequestProcessedAlpha1 event_processed = 2; + * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getEventProcessed = function() { + return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1, 2)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1|undefined} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this +*/ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.setEventProcessed = function(value) { + return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.clearEventProcessed = function() { + return this.setEventProcessed(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.hasEventProcessed = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject = function(includeInstance, msg) { + var f, obj = { + pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), + topic: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + deadLetterTopic: jspb.Message.getFieldWithDefault(msg, 4, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1; + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader(msg, reader); +}; + /** - * @param {?proto.dapr.proto.common.v1.InvokeRequest|undefined} value - * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this -*/ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.setMessage = function(value) { - return jspb.Message.setWrapperField(this, 3, value); + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setPubsubName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTopic(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setDeadLetterTopic(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.InvokeServiceRequest} returns this + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.clearMessage = function() { - return this.setMessage(undefined); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPubsubName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getTopic(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = /** @type {string} */ (jspb.Message.getField(message, 4)); + if (f != null) { + writer.writeString( + 4, + f + ); + } +}; + + +/** + * optional string pubsub_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getPubsubName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setPubsubName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string topic = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setTopic = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + +/** + * optional string dead_letter_topic = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getDeadLetterTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setDeadLetterTopic = function(value) { + return jspb.Message.setField(this, 4, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.clearDeadLetterTopic = function() { + return jspb.Message.setField(this, 4, undefined); }; @@ -2413,8 +6929,8 @@ proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.clearMessage = functi * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.InvokeServiceRequest.prototype.hasMessage = function() { - return jspb.Message.getField(this, 3) != null; +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.hasDeadLetterTopic = function() { + return jspb.Message.getField(this, 4) != null; }; @@ -2434,8 +6950,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject(opt_includeInstance, this); }; @@ -2444,16 +6960,14 @@ proto.dapr.proto.runtime.v1.GetStateRequest.prototype.toObject = function(opt_in * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - key: jspb.Message.getFieldWithDefault(msg, 2, ""), - consistency: jspb.Message.getFieldWithDefault(msg, 3, 0), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + status: (f = msg.getStatus()) && dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.toObject(includeInstance, f) }; if (includeInstance) { @@ -2467,23 +6981,23 @@ proto.dapr.proto.runtime.v1.GetStateRequest.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} */ -proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetStateRequest; - return proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1; + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} */ -proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -2492,21 +7006,12 @@ proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader = functi switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setId(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 3: - var value = /** @type {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} */ (reader.readEnum()); - msg.setConsistency(value); - break; - case 4: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = new dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse; + reader.readMessage(value,dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.deserializeBinaryFromReader); + msg.setStatus(value); break; default: reader.skipField(); @@ -2521,9 +7026,9 @@ proto.dapr.proto.runtime.v1.GetStateRequest.deserializeBinaryFromReader = functi * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -2531,124 +7036,111 @@ proto.dapr.proto.runtime.v1.GetStateRequest.prototype.serializeBinary = function /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getKey(); - if (f.length > 0) { - writer.writeString( + f = message.getStatus(); + if (f != null) { + writer.writeMessage( 2, - f - ); - } - f = message.getConsistency(); - if (f !== 0.0) { - writer.writeEnum( - 3, - f + f, + dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.serializeBinaryToWriter ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string store_name = 1; + * optional string id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getStoreName = function() { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.getId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setStoreName = function(value) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.setId = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string key = 2; - * @return {string} + * optional TopicEventResponse status = 2; + * @return {?proto.dapr.proto.runtime.v1.TopicEventResponse} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.getStatus = function() { + return /** @type{?proto.dapr.proto.runtime.v1.TopicEventResponse} */ ( + jspb.Message.getWrapperField(this, dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse, 2)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this - */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); + * @param {?proto.dapr.proto.runtime.v1.TopicEventResponse|undefined} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this +*/ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.setStatus = function(value) { + return jspb.Message.setWrapperField(this, 2, value); }; /** - * optional dapr.proto.common.v1.StateOptions.StateConsistency consistency = 3; - * @return {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getConsistency = function() { - return /** @type {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.clearStatus = function() { + return this.setStatus(undefined); }; /** - * @param {!proto.dapr.proto.common.v1.StateOptions.StateConsistency} value - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.setConsistency = function(value) { - return jspb.Message.setProto3EnumField(this, 3, value); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.hasStatus = function() { + return jspb.Message.getField(this, 2) != null; }; + /** - * map metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); -}; - +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_ = [[1,2]]; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetStateRequest} returns this + * @enum {number} */ -proto.dapr.proto.runtime.v1.GetStateRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase = { + SUBSCRIBE_TOPIC_EVENTS_RESPONSE_TYPE_NOT_SET: 0, + INITIAL_RESPONSE: 1, + EVENT_MESSAGE: 2 }; - - /** - * List of repeated fields within this message type. - * @private {!Array} - * @const + * @return {proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.repeatedFields_ = [2]; +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getSubscribeTopicEventsResponseTypeCase = function() { + return /** @type {proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0])); +}; @@ -2665,8 +7157,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetBulkStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.toObject(opt_includeInstance, this); }; @@ -2675,16 +7167,14 @@ proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, - parallelism: jspb.Message.getFieldWithDefault(msg, 3, 0), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + initialResponse: (f = msg.getInitialResponse()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject(includeInstance, f), + eventMessage: (f = msg.getEventMessage()) && dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.toObject(includeInstance, f) }; if (includeInstance) { @@ -2698,23 +7188,23 @@ proto.dapr.proto.runtime.v1.GetBulkStateRequest.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetBulkStateRequest; - return proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1; + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -2722,22 +7212,14 @@ proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader = fu var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1; + reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader); + msg.setInitialResponse(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.addKeys(value); - break; - case 3: - var value = /** @type {number} */ (reader.readInt32()); - msg.setParallelism(value); - break; - case 4: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = new dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest; + reader.readMessage(value,dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.deserializeBinaryFromReader); + msg.setEventMessage(value); break; default: reader.skipField(); @@ -2752,9 +7234,9 @@ proto.dapr.proto.runtime.v1.GetBulkStateRequest.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetBulkStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -2762,144 +7244,207 @@ proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( + f = message.getInitialResponse(); + if (f != null) { + writer.writeMessage( 1, - f + f, + proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter ); } - f = message.getKeysList(); - if (f.length > 0) { - writer.writeRepeatedString( + f = message.getEventMessage(); + if (f != null) { + writer.writeMessage( 2, - f - ); - } - f = message.getParallelism(); - if (f !== 0) { - writer.writeInt32( - 3, - f + f, + dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.serializeBinaryToWriter ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string store_name = 1; - * @return {string} + * optional SubscribeTopicEventsResponseInitialAlpha1 initial_response = 1; + * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getInitialResponse = function() { + return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1, 1)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1|undefined} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this +*/ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.setInitialResponse = function(value) { + return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.clearInitialResponse = function() { + return this.setInitialResponse(undefined); }; /** - * repeated string keys = 2; - * @return {!Array} + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getKeysList = function() { - return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.hasInitialResponse = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + * optional TopicEventRequest event_message = 2; + * @return {?proto.dapr.proto.runtime.v1.TopicEventRequest} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getEventMessage = function() { + return /** @type{?proto.dapr.proto.runtime.v1.TopicEventRequest} */ ( + jspb.Message.getWrapperField(this, dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest, 2)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.TopicEventRequest|undefined} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this +*/ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.setEventMessage = function(value) { + return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.clearEventMessage = function() { + return this.setEventMessage(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.hasEventMessage = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setKeysList = function(value) { - return jspb.Message.setField(this, 2, value || []); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject(opt_includeInstance, this); }; /** - * @param {string} value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.addKeys = function(value, opt_index) { - return jspb.Message.addToRepeatedField(this, 2, value, opt_index); -}; +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject = function(includeInstance, msg) { + var f, obj = { + }; -/** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this - */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.clearKeysList = function() { - return this.setKeysList([]); + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * optional int32 parallelism = 3; - * @return {number} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getParallelism = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1; + return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader(msg, reader); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.setParallelism = function(value) { - return jspb.Message.setProto3IntField(this, 3, value); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * map metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateRequest} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter = function(message, writer) { + var f = undefined; }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.repeatedFields_ = [1]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -2915,8 +7460,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetBulkStateResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.InvokeBindingRequest.toObject(opt_includeInstance, this); }; @@ -2925,14 +7470,16 @@ proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.InvokeBindingRequest.toObject = function(includeInstance, msg) { var f, obj = { - itemsList: jspb.Message.toObjectList(msg.getItemsList(), - proto.dapr.proto.runtime.v1.BulkStateItem.toObject, includeInstance) + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + data: msg.getData_asB64(), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + operation: jspb.Message.getFieldWithDefault(msg, 4, "") }; if (includeInstance) { @@ -2946,23 +7493,23 @@ proto.dapr.proto.runtime.v1.GetBulkStateResponse.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetBulkStateResponse; - return proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.InvokeBindingRequest; + return proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -2970,9 +7517,22 @@ proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader = f var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.BulkStateItem; - reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader); - msg.addItems(value); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setOperation(value); break; default: reader.skipField(); @@ -2987,9 +7547,9 @@ proto.dapr.proto.runtime.v1.GetBulkStateResponse.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetBulkStateResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.InvokeBindingRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -2997,58 +7557,137 @@ proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} message + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.InvokeBindingRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getItemsList(); + f = message.getName(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeString( 1, - f, - proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = message.getOperation(); + if (f.length > 0) { + writer.writeString( + 4, + f ); } }; /** - * repeated BulkStateItem items = 1; - * @return {!Array} + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.getItemsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkStateItem, 1)); +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.setItemsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes data = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes data = 2; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); }; /** - * @param {!proto.dapr.proto.runtime.v1.BulkStateItem=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + +/** + * optional string operation = 4; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.addItems = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.BulkStateItem, opt_index); +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getOperation = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetBulkStateResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this */ -proto.dapr.proto.runtime.v1.GetBulkStateResponse.prototype.clearItemsList = function() { - return this.setItemsList([]); +proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setOperation = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; @@ -3068,8 +7707,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.BulkStateItem.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.InvokeBindingResponse.toObject(opt_includeInstance, this); }; @@ -3078,16 +7717,13 @@ proto.dapr.proto.runtime.v1.BulkStateItem.prototype.toObject = function(opt_incl * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkStateItem.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.toObject = function(includeInstance, msg) { var f, obj = { - key: jspb.Message.getFieldWithDefault(msg, 1, ""), data: msg.getData_asB64(), - etag: jspb.Message.getFieldWithDefault(msg, 3, ""), - error: jspb.Message.getFieldWithDefault(msg, 4, ""), metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; @@ -3102,23 +7738,23 @@ proto.dapr.proto.runtime.v1.BulkStateItem.toObject = function(includeInstance, m /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} */ -proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.BulkStateItem; - return proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.InvokeBindingResponse; + return proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} */ -proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3126,22 +7762,10 @@ proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader = function var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 2: var value = /** @type {!Uint8Array} */ (reader.readBytes()); msg.setData(value); break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setEtag(value); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setError(value); - break; - case 5: + case 2: var value = msg.getMetadataMap(); reader.readMessage(value, function(message, reader) { jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); @@ -3160,9 +7784,9 @@ proto.dapr.proto.runtime.v1.BulkStateItem.deserializeBinaryFromReader = function * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.InvokeBindingResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3170,93 +7794,54 @@ proto.dapr.proto.runtime.v1.BulkStateItem.prototype.serializeBinary = function() /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.BulkStateItem} message + * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkStateItem.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } f = message.getData_asU8(); if (f.length > 0) { writer.writeBytes( - 2, - f - ); - } - f = message.getEtag(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getError(); - if (f.length > 0) { - writer.writeString( - 4, + 1, f ); } f = message.getMetadataMap(true); if (f && f.getLength() > 0) { - f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } }; /** - * optional string key = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional bytes data = 2; + * optional bytes data = 1; * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional bytes data = 2; + * optional bytes data = 1; * This is a type-conversion wrapper around `getData()` * @return {string} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData_asB64 = function() { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData_asB64 = function() { return /** @type {string} */ (jspb.Message.bytesAsB64( this.getData())); }; /** - * optional bytes data = 2; + * optional bytes data = 1; * Note that Uint8Array is not supported on all browsers. * @see http://caniuse.com/Uint8Array * This is a type-conversion wrapper around `getData()` * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData_asU8 = function() { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData_asU8 = function() { return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( this.getData())); }; @@ -3264,70 +7849,33 @@ proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getData_asU8 = function() { /** * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; - - -/** - * optional string etag = 3; - * @return {string} - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getEtag = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setEtag = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional string error = 4; - * @return {string} - */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getError = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} returns this */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.setError = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; /** - * map metadata = 5; + * map metadata = 2; * @param {boolean=} opt_noLazyCreate Do not create the map if * empty, instead returning `undefined` * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.getMetadataMap = function(opt_noLazyCreate) { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 5, opt_noLazyCreate, + jspb.Message.getMapField(this, 2, opt_noLazyCreate, null)); }; /** * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.BulkStateItem} returns this + * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} returns this */ -proto.dapr.proto.runtime.v1.BulkStateItem.prototype.clearMetadataMap = function() { +proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; @@ -3346,8 +7894,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetStateResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetSecretRequest.toObject(opt_includeInstance, this); }; @@ -3356,14 +7904,14 @@ proto.dapr.proto.runtime.v1.GetStateResponse.prototype.toObject = function(opt_i * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetStateResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetSecretRequest.toObject = function(includeInstance, msg) { var f, obj = { - data: msg.getData_asB64(), - etag: jspb.Message.getFieldWithDefault(msg, 2, ""), + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + key: jspb.Message.getFieldWithDefault(msg, 2, ""), metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; @@ -3378,23 +7926,23 @@ proto.dapr.proto.runtime.v1.GetStateResponse.toObject = function(includeInstance /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} + * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} */ -proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetStateResponse; - return proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetSecretRequest; + return proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} + * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} */ -proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3402,12 +7950,12 @@ proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader = funct var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setEtag(value); + msg.setKey(value); break; case 3: var value = msg.getMetadataMap(); @@ -3428,9 +7976,9 @@ proto.dapr.proto.runtime.v1.GetStateResponse.deserializeBinaryFromReader = funct * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetStateResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetSecretRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3438,20 +7986,20 @@ proto.dapr.proto.runtime.v1.GetStateResponse.prototype.serializeBinary = functio /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetStateResponse} message + * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetStateResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetSecretRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getData_asU8(); + f = message.getStoreName(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 1, f ); } - f = message.getEtag(); + f = message.getKey(); if (f.length > 0) { writer.writeString( 2, @@ -3466,61 +8014,37 @@ proto.dapr.proto.runtime.v1.GetStateResponse.serializeBinaryToWriter = function( /** - * optional bytes data = 1; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes data = 1; - * This is a type-conversion wrapper around `getData()` + * optional string store_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string etag = 2; + * optional string key = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getEtag = function() { +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getKey = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.setEtag = function(value) { +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.setKey = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; @@ -3531,7 +8055,7 @@ proto.dapr.proto.runtime.v1.GetStateResponse.prototype.setEtag = function(value) * empty, instead returning `undefined` * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { return /** @type {!jspb.Map} */ ( jspb.Message.getMapField(this, 3, opt_noLazyCreate, null)); @@ -3540,12 +8064,11 @@ proto.dapr.proto.runtime.v1.GetStateResponse.prototype.getMetadataMap = function /** * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetStateResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this */ -proto.dapr.proto.runtime.v1.GetStateResponse.prototype.clearMetadataMap = function() { +proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; @@ -3564,8 +8087,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DeleteStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetSecretResponse.toObject(opt_includeInstance, this); }; @@ -3574,17 +8097,13 @@ proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetSecretResponse.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - key: jspb.Message.getFieldWithDefault(msg, 2, ""), - etag: (f = msg.getEtag()) && dapr_proto_common_v1_common_pb.Etag.toObject(includeInstance, f), - options: (f = msg.getOptions()) && dapr_proto_common_v1_common_pb.StateOptions.toObject(includeInstance, f), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + dataMap: (f = msg.getDataMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -3598,23 +8117,23 @@ proto.dapr.proto.runtime.v1.DeleteStateRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} + * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DeleteStateRequest; - return proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetSecretResponse; + return proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} + * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3622,25 +8141,7 @@ proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader = fun var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 3: - var value = new dapr_proto_common_v1_common_pb.Etag; - reader.readMessage(value,dapr_proto_common_v1_common_pb.Etag.deserializeBinaryFromReader); - msg.setEtag(value); - break; - case 4: - var value = new dapr_proto_common_v1_common_pb.StateOptions; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StateOptions.deserializeBinaryFromReader); - msg.setOptions(value); - break; - case 5: - var value = msg.getMetadataMap(); + var value = msg.getDataMap(); reader.readMessage(value, function(message, reader) { jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); }); @@ -3658,9 +8159,9 @@ proto.dapr.proto.runtime.v1.DeleteStateRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DeleteStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetSecretResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3668,189 +8169,204 @@ proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DeleteStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetSecretResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getEtag(); - if (f != null) { - writer.writeMessage( - 3, - f, - dapr_proto_common_v1_common_pb.Etag.serializeBinaryToWriter - ); - } - f = message.getOptions(); - if (f != null) { - writer.writeMessage( - 4, - f, - dapr_proto_common_v1_common_pb.StateOptions.serializeBinaryToWriter - ); - } - f = message.getMetadataMap(true); + f = message.getDataMap(true); if (f && f.getLength() > 0) { - f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } }; /** - * optional string store_name = 1; - * @return {string} + * map data = 1; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.getDataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 1, opt_noLazyCreate, + null)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} returns this */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; +proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.clearDataMap = function() { + this.getDataMap().clear(); + return this;}; -/** - * optional string key = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; + +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetBulkSecretRequest.toObject(opt_includeInstance, this); }; /** - * optional dapr.proto.common.v1.Etag etag = 3; - * @return {?proto.dapr.proto.common.v1.Etag} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getEtag = function() { - return /** @type{?proto.dapr.proto.common.v1.Etag} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.Etag, 3)); -}; - +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; -/** - * @param {?proto.dapr.proto.common.v1.Etag|undefined} value - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this -*/ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setEtag = function(value) { - return jspb.Message.setWrapperField(this, 3, value); + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearEtag = function() { - return this.setEtag(undefined); +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetBulkSecretRequest; + return proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader(msg, reader); }; /** - * Returns whether this field is set. - * @return {boolean} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.hasEtag = function() { - return jspb.Message.getField(this, 3) != null; +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional dapr.proto.common.v1.StateOptions options = 4; - * @return {?proto.dapr.proto.common.v1.StateOptions} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getOptions = function() { - return /** @type{?proto.dapr.proto.common.v1.StateOptions} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StateOptions, 4)); +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetBulkSecretRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * @param {?proto.dapr.proto.common.v1.StateOptions|undefined} value - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this -*/ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.setOptions = function(value) { - return jspb.Message.setWrapperField(this, 4, value); + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + * optional string store_name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearOptions = function() { - return this.setOptions(undefined); +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} returns this */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.hasOptions = function() { - return jspb.Message.getField(this, 4) != null; +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * map metadata = 5; + * map metadata = 2; * @param {boolean=} opt_noLazyCreate Do not create the map if * empty, instead returning `undefined` * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 5, opt_noLazyCreate, + jspb.Message.getMapField(this, 2, opt_noLazyCreate, null)); }; /** * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.DeleteStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} returns this */ -proto.dapr.proto.runtime.v1.DeleteStateRequest.prototype.clearMetadataMap = function() { +proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; - + return this;}; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.repeatedFields_ = [2]; @@ -3867,8 +8383,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SecretResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SecretResponse.toObject(opt_includeInstance, this); }; @@ -3877,15 +8393,13 @@ proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.toObject = function * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SecretResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SecretResponse.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - statesList: jspb.Message.toObjectList(msg.getStatesList(), - dapr_proto_common_v1_common_pb.StateItem.toObject, includeInstance) + secretsMap: (f = msg.getSecretsMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -3899,23 +8413,23 @@ proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.toObject = function(includeIn /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SecretResponse} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DeleteBulkStateRequest; - return proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SecretResponse; + return proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SecretResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SecretResponse} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -3923,13 +8437,10 @@ proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); - break; - case 2: - var value = new dapr_proto_common_v1_common_pb.StateItem; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StateItem.deserializeBinaryFromReader); - msg.addStates(value); + var value = msg.getSecretsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; default: reader.skipField(); @@ -3944,9 +8455,9 @@ proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SecretResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -3954,93 +8465,174 @@ proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.serializeBinary = f /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.SecretResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getStatesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 2, - f, - dapr_proto_common_v1_common_pb.StateItem.serializeBinaryToWriter - ); + f = message.getSecretsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } }; /** - * optional string store_name = 1; - * @return {string} + * map secrets = 1; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SecretResponse.prototype.getSecretsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 1, opt_noLazyCreate, + null)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.SecretResponse} returns this */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SecretResponse.prototype.clearSecretsMap = function() { + this.getSecretsMap().clear(); + return this;}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetBulkSecretResponse.toObject(opt_includeInstance, this); }; /** - * repeated dapr.proto.common.v1.StateItem states = 2; - * @return {!Array} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.getStatesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.toObject = function(includeInstance, msg) { + var f, obj = { + dataMap: (f = msg.getDataMap()) ? f.toObject(includeInstance, proto.dapr.proto.runtime.v1.SecretResponse.toObject) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this -*/ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.setStatesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} + */ +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetBulkSecretResponse; + return proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader(msg, reader); }; /** - * @param {!proto.dapr.proto.common.v1.StateItem=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.common.v1.StateItem} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.addStates = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.common.v1.StateItem, opt_index); +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = msg.getDataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader, "", new proto.dapr.proto.runtime.v1.SecretResponse()); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.DeleteBulkStateRequest} returns this + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DeleteBulkStateRequest.prototype.clearStatesList = function() { - return this.setStatesList([]); +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetBulkSecretResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter); + } +}; + + +/** + * map data = 1; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.getDataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 1, opt_noLazyCreate, + proto.dapr.proto.runtime.v1.SecretResponse)); }; +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.clearDataMap = function() { + this.getDataMap().clear(); + return this;}; + -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.SaveStateRequest.repeatedFields_ = [2]; @@ -4057,8 +8649,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SaveStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject(opt_includeInstance, this); }; @@ -4067,15 +8659,14 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.toObject = function(opt_i * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SaveStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - statesList: jspb.Message.toObjectList(msg.getStatesList(), - dapr_proto_common_v1_common_pb.StateItem.toObject, includeInstance) + operationtype: jspb.Message.getFieldWithDefault(msg, 1, ""), + request: (f = msg.getRequest()) && dapr_proto_common_v1_common_pb.StateItem.toObject(includeInstance, f) }; if (includeInstance) { @@ -4089,23 +8680,23 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.toObject = function(includeInstance /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SaveStateRequest; - return proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.TransactionalStateOperation; + return proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -4114,12 +8705,12 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader = funct switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setOperationtype(value); break; case 2: var value = new dapr_proto_common_v1_common_pb.StateItem; reader.readMessage(value,dapr_proto_common_v1_common_pb.StateItem.deserializeBinaryFromReader); - msg.addStates(value); + msg.setRequest(value); break; default: reader.skipField(); @@ -4134,9 +8725,9 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.deserializeBinaryFromReader = funct * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SaveStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -4144,22 +8735,22 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.serializeBinary = functio /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SaveStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SaveStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getOperationtype(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getStatesList(); - if (f.length > 0) { - writer.writeRepeatedMessage( + f = message.getRequest(); + if (f != null) { + writer.writeMessage( 2, f, dapr_proto_common_v1_common_pb.StateItem.serializeBinaryToWriter @@ -4169,62 +8760,68 @@ proto.dapr.proto.runtime.v1.SaveStateRequest.serializeBinaryToWriter = function( /** - * optional string store_name = 1; + * optional string operationType = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.getStoreName = function() { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.getOperationtype = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.setStoreName = function(value) { +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.setOperationtype = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * repeated dapr.proto.common.v1.StateItem states = 2; - * @return {!Array} + * optional dapr.proto.common.v1.StateItem request = 2; + * @return {?proto.dapr.proto.common.v1.StateItem} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.getStatesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.getRequest = function() { + return /** @type{?proto.dapr.proto.common.v1.StateItem} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this + * @param {?proto.dapr.proto.common.v1.StateItem|undefined} value + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.setStatesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.setRequest = function(value) { + return jspb.Message.setWrapperField(this, 2, value); }; /** - * @param {!proto.dapr.proto.common.v1.StateItem=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.common.v1.StateItem} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.addStates = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.common.v1.StateItem, opt_index); +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.clearRequest = function() { + return this.setRequest(undefined); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.SaveStateRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SaveStateRequest.prototype.clearStatesList = function() { - return this.setStatesList([]); +proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.hasRequest = function() { + return jspb.Message.getField(this, 2) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -4240,8 +8837,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.QueryStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.toObject(opt_includeInstance, this); }; @@ -4250,14 +8847,15 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.toObject = function(opt_ * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - query: jspb.Message.getFieldWithDefault(msg, 2, ""), + storename: jspb.Message.getFieldWithDefault(msg, 1, ""), + operationsList: jspb.Message.toObjectList(msg.getOperationsList(), + proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject, includeInstance), metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; @@ -4272,23 +8870,23 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.toObject = function(includeInstanc /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.QueryStateRequest; - return proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest; + return proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -4297,11 +8895,12 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader = func switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setStorename(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setQuery(value); + var value = new proto.dapr.proto.runtime.v1.TransactionalStateOperation; + reader.readMessage(value,proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader); + msg.addOperations(value); break; case 3: var value = msg.getMetadataMap(); @@ -4322,9 +8921,9 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.deserializeBinaryFromReader = func * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.QueryStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -4332,24 +8931,25 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.serializeBinary = functi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.QueryStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getStorename(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getQuery(); + f = message.getOperationsList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 2, - f + f, + proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter ); } f = message.getMetadataMap(true); @@ -4360,38 +8960,58 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.serializeBinaryToWriter = function /** - * optional string store_name = 1; + * optional string storeName = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getStoreName = function() { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getStorename = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.setStoreName = function(value) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.setStorename = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string query = 2; - * @return {string} + * repeated TransactionalStateOperation operations = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getQuery = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getOperationsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.TransactionalStateOperation, 2)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this +*/ +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.setOperationsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.setQuery = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.addOperations = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.TransactionalStateOperation, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this + */ +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.clearOperationsList = function() { + return this.setOperationsList([]); }; @@ -4401,7 +9021,7 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.setQuery = function(valu * empty, instead returning `undefined` * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { return /** @type {!jspb.Map} */ ( jspb.Message.getMapField(this, 3, opt_noLazyCreate, null)); @@ -4410,12 +9030,11 @@ proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.getMetadataMap = functio /** * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.QueryStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateRequest.prototype.clearMetadataMap = function() { +proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.clearMetadataMap = function() { this.getMetadataMap().clear(); - return this; -}; + return this;}; @@ -4434,8 +9053,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.QueryStateItem.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.toObject(opt_includeInstance, this); }; @@ -4444,16 +9063,20 @@ proto.dapr.proto.runtime.v1.QueryStateItem.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateItem.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.toObject = function(includeInstance, msg) { var f, obj = { - key: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, ""), + dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), + period: jspb.Message.getFieldWithDefault(msg, 5, ""), + callback: jspb.Message.getFieldWithDefault(msg, 6, ""), data: msg.getData_asB64(), - etag: jspb.Message.getFieldWithDefault(msg, 3, ""), - error: jspb.Message.getFieldWithDefault(msg, 4, "") + ttl: jspb.Message.getFieldWithDefault(msg, 8, "") }; if (includeInstance) { @@ -4467,44 +9090,60 @@ proto.dapr.proto.runtime.v1.QueryStateItem.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} */ -proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.QueryStateItem; - return proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.RegisterActorTimerRequest; + return proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} */ -proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setActorType(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setActorId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setDueTime(value); + break; + case 5: var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); + msg.setPeriod(value); break; - case 2: + case 6: + var value = /** @type {string} */ (reader.readString()); + msg.setCallback(value); + break; + case 7: var value = /** @type {!Uint8Array} */ (reader.readBytes()); msg.setData(value); break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setEtag(value); - break; - case 4: + case 8: var value = /** @type {string} */ (reader.readString()); - msg.setError(value); + msg.setTtl(value); break; default: reader.skipField(); @@ -4519,9 +9158,9 @@ proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -4529,146 +9168,239 @@ proto.dapr.proto.runtime.v1.QueryStateItem.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.QueryStateItem} message + * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getKey(); + f = message.getActorType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getData_asU8(); + f = message.getActorId(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 2, f ); } - f = message.getEtag(); + f = message.getName(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getError(); + f = message.getDueTime(); if (f.length > 0) { writer.writeString( 4, f ); } + f = message.getPeriod(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } + f = message.getCallback(); + if (f.length > 0) { + writer.writeString( + 6, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 7, + f + ); + } + f = message.getTtl(); + if (f.length > 0) { + writer.writeString( + 8, + f + ); + } }; /** - * optional string key = 1; + * optional string actor_type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getKey = function() { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getActorType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setKey = function(value) { +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setActorType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes data = 2; - * @return {!(string|Uint8Array)} + * optional string actor_id = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getActorId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * optional bytes data = 2; - * This is a type-conversion wrapper around `getData()` + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setActorId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string name = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * optional bytes data = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + * optional string due_time = 4; + * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getDueTime = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * optional string etag = 3; + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setDueTime = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional string period = 5; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getEtag = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getPeriod = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setEtag = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setPeriod = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); }; /** - * optional string error = 4; + * optional string callback = 6; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.getError = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getCallback = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateItem.prototype.setError = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setCallback = function(value) { + return jspb.Message.setProto3StringField(this, 6, value); +}; + + +/** + * optional bytes data = 7; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); }; +/** + * optional bytes data = 7; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + /** - * List of repeated fields within this message type. - * @private {!Array} - * @const + * optional bytes data = 7; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.repeatedFields_ = [1]; +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 7, value); +}; + + +/** + * optional string ttl = 8; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getTtl = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 8, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setTtl = function(value) { + return jspb.Message.setProto3StringField(this, 8, value); +}; + + @@ -4685,8 +9417,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.QueryStateResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.toObject(opt_includeInstance, this); }; @@ -4695,16 +9427,15 @@ proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.toObject = function(includeInstance, msg) { var f, obj = { - resultsList: jspb.Message.toObjectList(msg.getResultsList(), - proto.dapr.proto.runtime.v1.QueryStateItem.toObject, includeInstance), - token: jspb.Message.getFieldWithDefault(msg, 2, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, "") }; if (includeInstance) { @@ -4718,23 +9449,23 @@ proto.dapr.proto.runtime.v1.QueryStateResponse.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.QueryStateResponse; - return proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest; + return proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -4742,19 +9473,16 @@ proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader = fun var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.QueryStateItem; - reader.readMessage(value,proto.dapr.proto.runtime.v1.QueryStateItem.deserializeBinaryFromReader); - msg.addResults(value); + var value = /** @type {string} */ (reader.readString()); + msg.setActorType(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setToken(value); - break; - case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + msg.setActorId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; default: reader.skipField(); @@ -4769,9 +9497,9 @@ proto.dapr.proto.runtime.v1.QueryStateResponse.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.QueryStateResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -4779,110 +9507,87 @@ proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.QueryStateResponse} message + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.QueryStateResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getResultsList(); + f = message.getActorType(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeString( 1, - f, - proto.dapr.proto.runtime.v1.QueryStateItem.serializeBinaryToWriter + f ); } - f = message.getToken(); + f = message.getActorId(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); } }; /** - * repeated QueryStateItem results = 1; - * @return {!Array} - */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getResultsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.QueryStateItem, 1)); -}; - - -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this -*/ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.setResultsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); -}; - - -/** - * @param {!proto.dapr.proto.runtime.v1.QueryStateItem=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.QueryStateItem} + * optional string actor_type = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.addResults = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.QueryStateItem, opt_index); +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getActorType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.clearResultsList = function() { - return this.setResultsList([]); +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setActorType = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string token = 2; + * optional string actor_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getToken = function() { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getActorId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.setToken = function(value) { +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setActorId = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string name = 3; + * @return {string} */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.QueryStateResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this */ -proto.dapr.proto.runtime.v1.QueryStateResponse.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; @@ -4902,8 +9607,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PublishEventRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.toObject(opt_includeInstance, this); }; @@ -4912,17 +9617,19 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PublishEventRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.toObject = function(includeInstance, msg) { var f, obj = { - pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), - topic: jspb.Message.getFieldWithDefault(msg, 2, ""), + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, ""), + dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), + period: jspb.Message.getFieldWithDefault(msg, 5, ""), data: msg.getData_asB64(), - dataContentType: jspb.Message.getFieldWithDefault(msg, 4, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + ttl: jspb.Message.getFieldWithDefault(msg, 7, "") }; if (includeInstance) { @@ -4936,23 +9643,23 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PublishEventRequest; - return proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.RegisterActorReminderRequest; + return proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -4961,25 +9668,31 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader = fu switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setPubsubName(value); + msg.setActorType(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setTopic(value); + msg.setActorId(value); break; case 3: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; case 4: var value = /** @type {string} */ (reader.readString()); - msg.setDataContentType(value); + msg.setDueTime(value); break; case 5: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setPeriod(value); + break; + case 6: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 7: + var value = /** @type {string} */ (reader.readString()); + msg.setTtl(value); break; default: reader.skipField(); @@ -4994,9 +9707,9 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PublishEventRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -5004,111 +9717,182 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PublishEventRequest} message + * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PublishEventRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getPubsubName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getTopic(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 3, - f - ); - } - f = message.getDataContentType(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getActorType(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getActorId(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getDueTime(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getPeriod(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 6, + f + ); + } + f = message.getTtl(); + if (f.length > 0) { + writer.writeString( + 7, + f + ); + } +}; + + +/** + * optional string actor_type = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getActorType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setActorType = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string actor_id = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getActorId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setActorId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string name = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + */ +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional string pubsub_name = 1; + * optional string due_time = 4; * @return {string} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getPubsubName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getDueTime = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setPubsubName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setDueTime = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; /** - * optional string topic = 2; + * optional string period = 5; * @return {string} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getTopic = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getPeriod = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setTopic = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setPeriod = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); }; /** - * optional bytes data = 3; + * optional bytes data = 6; * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); }; /** - * optional bytes data = 3; + * optional bytes data = 6; * This is a type-conversion wrapper around `getData()` * @return {string} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData_asB64 = function() { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData_asB64 = function() { return /** @type {string} */ (jspb.Message.bytesAsB64( this.getData())); }; /** - * optional bytes data = 3; + * optional bytes data = 6; * Note that Uint8Array is not supported on all browsers. * @see http://caniuse.com/Uint8Array * This is a type-conversion wrapper around `getData()` * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData_asU8 = function() { +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData_asU8 = function() { return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( this.getData())); }; @@ -5116,62 +9900,32 @@ proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getData_asU8 = functio /** * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 3, value); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 6, value); }; /** - * optional string data_content_type = 4; + * optional string ttl = 7; * @return {string} */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getDataContentType = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getTtl = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this - */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.setDataContentType = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); -}; - - -/** - * map metadata = 5; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} - */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 5, opt_noLazyCreate, - null)); -}; - - -/** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.PublishEventRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.PublishEventRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setTtl = function(value) { + return jspb.Message.setProto3StringField(this, 7, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.repeatedFields_ = [3]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -5187,8 +9941,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.BulkPublishRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.toObject(opt_includeInstance, this); }; @@ -5197,17 +9951,15 @@ proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.toObject = function(includeInstance, msg) { var f, obj = { - pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), - topic: jspb.Message.getFieldWithDefault(msg, 2, ""), - entriesList: jspb.Message.toObjectList(msg.getEntriesList(), - proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject, includeInstance), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, "") }; if (includeInstance) { @@ -5221,23 +9973,23 @@ proto.dapr.proto.runtime.v1.BulkPublishRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.BulkPublishRequest; - return proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest; + return proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -5246,22 +9998,15 @@ proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader = fun switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setPubsubName(value); + msg.setActorType(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setTopic(value); + msg.setActorId(value); break; case 3: - var value = new proto.dapr.proto.runtime.v1.BulkPublishRequestEntry; - reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader); - msg.addEntries(value); - break; - case 4: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; default: reader.skipField(); @@ -5276,9 +10021,9 @@ proto.dapr.proto.runtime.v1.BulkPublishRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.BulkPublishRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -5286,135 +10031,87 @@ proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequest} message + * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPubsubName(); + f = message.getActorType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getTopic(); + f = message.getActorId(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getEntriesList(); + f = message.getName(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeString( 3, - f, - proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter + f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string pubsub_name = 1; + * optional string actor_type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getPubsubName = function() { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getActorType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setPubsubName = function(value) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setActorType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string topic = 2; + * optional string actor_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getTopic = function() { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getActorId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setTopic = function(value) { +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setActorId = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; /** - * repeated BulkPublishRequestEntry entries = 3; - * @return {!Array} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getEntriesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkPublishRequestEntry, 3)); -}; - - -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this -*/ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.setEntriesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 3, value); -}; - - -/** - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.addEntries = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.BulkPublishRequestEntry, opt_index); -}; - - -/** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this - */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.clearEntriesList = function() { - return this.setEntriesList([]); -}; - - -/** - * map metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); + * optional string name = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; @@ -5434,8 +10131,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetActorStateRequest.toObject(opt_includeInstance, this); }; @@ -5444,16 +10141,15 @@ proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.toObject = functio * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.toObject = function(includeInstance, msg) { var f, obj = { - entryId: jspb.Message.getFieldWithDefault(msg, 1, ""), - event: msg.getEvent_asB64(), - contentType: jspb.Message.getFieldWithDefault(msg, 3, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + key: jspb.Message.getFieldWithDefault(msg, 3, "") }; if (includeInstance) { @@ -5467,23 +10163,23 @@ proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.toObject = function(includeI /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} + * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.BulkPublishRequestEntry; - return proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetActorStateRequest; + return proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} + * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -5492,21 +10188,15 @@ proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setEntryId(value); + msg.setActorType(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setEvent(value); + var value = /** @type {string} */ (reader.readString()); + msg.setActorId(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setContentType(value); - break; - case 4: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + msg.setKey(value); break; default: reader.skipField(); @@ -5521,9 +10211,9 @@ proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetActorStateRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -5531,148 +10221,90 @@ proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} message + * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getEntryId(); + f = message.getActorType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getEvent_asU8(); + f = message.getActorId(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 2, f ); } - f = message.getContentType(); + f = message.getKey(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string entry_id = 1; + * optional string actor_type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEntryId = function() { +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getActorType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setEntryId = function(value) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setActorType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes event = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes event = 2; - * This is a type-conversion wrapper around `getEvent()` + * optional string actor_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getEvent())); -}; - - -/** - * optional bytes event = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getEvent()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getEvent_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getEvent())); +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getActorId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setEvent = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setActorId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional string content_type = 3; + * optional string key = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getContentType = function() { +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getKey = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this + * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.setContentType = function(value) { +proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setKey = function(value) { return jspb.Message.setProto3StringField(this, 3, value); }; -/** - * map metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} - */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); -}; - - -/** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishRequestEntry} returns this - */ -proto.dapr.proto.runtime.v1.BulkPublishRequestEntry.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; -}; - - - -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.repeatedFields_ = [1]; @@ -5689,8 +10321,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.BulkPublishResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetActorStateResponse.toObject(opt_includeInstance, this); }; @@ -5699,14 +10331,14 @@ proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetActorStateResponse.toObject = function(includeInstance, msg) { var f, obj = { - failedentriesList: jspb.Message.toObjectList(msg.getFailedentriesList(), - proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject, includeInstance) + data: msg.getData_asB64(), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -5720,23 +10352,23 @@ proto.dapr.proto.runtime.v1.BulkPublishResponse.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} + * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.BulkPublishResponse; - return proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetActorStateResponse; + return proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} + * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -5744,9 +10376,14 @@ proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader = fu var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry; - reader.readMessage(value,proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader); - msg.addFailedentries(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 2: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; default: reader.skipField(); @@ -5761,9 +10398,9 @@ proto.dapr.proto.runtime.v1.BulkPublishResponse.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.BulkPublishResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetActorStateResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -5771,61 +10408,97 @@ proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponse} message + * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetActorStateResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getFailedentriesList(); + f = message.getData_asU8(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeBytes( 1, - f, - proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter + f ); } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * repeated BulkPublishResponseFailedEntry failedEntries = 1; - * @return {!Array} + * optional bytes data = 1; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.getFailedentriesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry, 1)); +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} returns this -*/ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.setFailedentriesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); + * optional bytes data = 1; + * This is a type-conversion wrapper around `getData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); +}; + + +/** + * optional bytes data = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; /** - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + * map metadata = 2; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.addFailedentries = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry, opt_index); +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 2, opt_noLazyCreate, + null)); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponse} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishResponse.prototype.clearFailedentriesList = function() { - return this.setFailedentriesList([]); -}; +proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.repeatedFields_ = [3]; @@ -5842,8 +10515,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.toObject(opt_includeInstance, this); }; @@ -5852,14 +10525,16 @@ proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.toObject = * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.toObject = function(includeInstance, msg) { var f, obj = { - entryId: jspb.Message.getFieldWithDefault(msg, 1, ""), - error: jspb.Message.getFieldWithDefault(msg, 2, "") + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + operationsList: jspb.Message.toObjectList(msg.getOperationsList(), + proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject, includeInstance) }; if (includeInstance) { @@ -5873,23 +10548,23 @@ proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.toObject = function(i /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry; - return proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest; + return proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -5898,11 +10573,16 @@ proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFrom switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setEntryId(value); + msg.setActorType(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setError(value); + msg.setActorId(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.TransactionalActorStateOperation; + reader.readMessage(value,proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader); + msg.addOperations(value); break; default: reader.skipField(); @@ -5917,9 +10597,9 @@ proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.deserializeBinaryFrom * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -5927,94 +10607,114 @@ proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.serializeBi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} message + * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getEntryId(); + f = message.getActorType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getError(); + f = message.getActorId(); if (f.length > 0) { writer.writeString( 2, f ); } + f = message.getOperationsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter + ); + } }; /** - * optional string entry_id = 1; + * optional string actor_type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.getEntryId = function() { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getActorType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} returns this + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.setEntryId = function(value) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setActorType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string error = 2; + * optional string actor_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.getError = function() { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getActorId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry} returns this + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this */ -proto.dapr.proto.runtime.v1.BulkPublishResponseFailedEntry.prototype.setError = function(value) { +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setActorId = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; - /** - * Oneof group definitions for this message. Each group defines the field - * numbers belonging to that group. When of these fields' value is set, all - * other fields in the group are cleared. During deserialization, if multiple - * fields are encountered for a group, only the last value seen will be kept. - * @private {!Array>} - * @const + * repeated TransactionalActorStateOperation operations = 3; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_ = [[1,2]]; +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getOperationsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.TransactionalActorStateOperation, 3)); +}; + /** - * @enum {number} + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this +*/ +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setOperationsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase = { - SUBSCRIBE_TOPIC_EVENTS_REQUEST_TYPE_NOT_SET: 0, - INITIAL_REQUEST: 1, - EVENT_PROCESSED: 2 +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.addOperations = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.TransactionalActorStateOperation, opt_index); }; + /** - * @return {proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getSubscribeTopicEventsRequestTypeCase = function() { - return /** @type {proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.SubscribeTopicEventsRequestTypeCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0])); +proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.clearOperationsList = function() { + return this.setOperationsList([]); }; + + if (jspb.Message.GENERATE_TO_OBJECT) { /** * Creates an object representation of this proto. @@ -6028,8 +10728,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject(opt_includeInstance, this); }; @@ -6038,14 +10738,16 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.toObject * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject = function(includeInstance, msg) { var f, obj = { - initialRequest: (f = msg.getInitialRequest()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject(includeInstance, f), - eventProcessed: (f = msg.getEventProcessed()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject(includeInstance, f) + operationtype: jspb.Message.getFieldWithDefault(msg, 1, ""), + key: jspb.Message.getFieldWithDefault(msg, 2, ""), + value: (f = msg.getValue()) && google_protobuf_any_pb.Any.toObject(includeInstance, f), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -6059,23 +10761,23 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.toObject = functio /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1; - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.TransactionalActorStateOperation; + return proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -6083,14 +10785,23 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryF var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1; - reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader); - msg.setInitialRequest(value); + var value = /** @type {string} */ (reader.readString()); + msg.setOperationtype(value); break; case 2: - var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1; - reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader); - msg.setEventProcessed(value); + var value = /** @type {string} */ (reader.readString()); + msg.setKey(value); + break; + case 3: + var value = new google_protobuf_any_pb.Any; + reader.readMessage(value,google_protobuf_any_pb.Any.deserializeBinaryFromReader); + msg.setValue(value); + break; + case 4: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; default: reader.skipField(); @@ -6105,9 +10816,9 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.deserializeBinaryF * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -6115,93 +10826,102 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.serializ /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} message + * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInitialRequest(); - if (f != null) { - writer.writeMessage( + f = message.getOperationtype(); + if (f.length > 0) { + writer.writeString( 1, - f, - proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter + f ); } - f = message.getEventProcessed(); + f = message.getKey(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getValue(); if (f != null) { writer.writeMessage( - 2, + 3, f, - proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter + google_protobuf_any_pb.Any.serializeBinaryToWriter ); } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * optional SubscribeTopicEventsRequestInitialAlpha1 initial_request = 1; - * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + * optional string operationType = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getInitialRequest = function() { - return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1, 1)); +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getOperationtype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1|undefined} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this -*/ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.setInitialRequest = function(value) { - return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0], value); + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this + */ +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setOperationtype = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.clearInitialRequest = function() { - return this.setInitialRequest(undefined); + * optional string key = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.hasInitialRequest = function() { - return jspb.Message.getField(this, 1) != null; +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setKey = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional SubscribeTopicEventsRequestProcessedAlpha1 event_processed = 2; - * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} + * optional google.protobuf.Any value = 3; + * @return {?proto.google.protobuf.Any} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.getEventProcessed = function() { - return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1, 2)); +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getValue = function() { + return /** @type{?proto.google.protobuf.Any} */ ( + jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 3)); }; /** - * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1|undefined} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this + * @param {?proto.google.protobuf.Any|undefined} value + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.setEventProcessed = function(value) { - return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.oneofGroups_[0], value); +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setValue = function(value) { + return jspb.Message.setWrapperField(this, 3, value); }; /** * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1} returns this + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.clearEventProcessed = function() { - return this.setEventProcessed(undefined); +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.clearValue = function() { + return this.setValue(undefined); }; @@ -6209,11 +10929,33 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.clearEve * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.prototype.hasEventProcessed = function() { - return jspb.Message.getField(this, 2) != null; +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.hasValue = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * map metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); }; +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this + */ +proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + @@ -6230,8 +10972,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.InvokeActorRequest.toObject(opt_includeInstance, this); }; @@ -6240,16 +10982,17 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.t * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.toObject = function(includeInstance, msg) { var f, obj = { - pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), - topic: jspb.Message.getFieldWithDefault(msg, 2, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], - deadLetterTopic: jspb.Message.getFieldWithDefault(msg, 4, "") + actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), + actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), + method: jspb.Message.getFieldWithDefault(msg, 3, ""), + data: msg.getData_asB64(), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -6263,23 +11006,23 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.toObject = /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1; - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.InvokeActorRequest; + return proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -6288,22 +11031,26 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserialize switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setPubsubName(value); + msg.setActorType(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setTopic(value); + msg.setActorId(value); break; case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setMethod(value); + break; + case 4: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); + break; + case 5: var value = msg.getMetadataMap(); reader.readMessage(value, function(message, reader) { jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); }); break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setDeadLetterTopic(value); - break; default: reader.skipField(); break; @@ -6317,9 +11064,9 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.deserialize * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.InvokeActorRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -6327,135 +11074,165 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.s /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} message + * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPubsubName(); + f = message.getActorType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getTopic(); + f = message.getActorId(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } - f = /** @type {string} */ (jspb.Message.getField(message, 4)); - if (f != null) { + f = message.getMethod(); + if (f.length > 0) { writer.writeString( + 3, + f + ); + } + f = message.getData_asU8(); + if (f.length > 0) { + writer.writeBytes( 4, f ); } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * optional string pubsub_name = 1; + * optional string actor_type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getPubsubName = function() { +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getActorType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setPubsubName = function(value) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setActorType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string topic = 2; + * optional string actor_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getTopic = function() { +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getActorId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setTopic = function(value) { +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setActorId = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string method = 3; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getMethod = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setMethod = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional string dead_letter_topic = 4; + * optional bytes data = 4; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * optional bytes data = 4; + * This is a type-conversion wrapper around `getData()` * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.getDeadLetterTopic = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + * optional bytes data = 4; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.setDeadLetterTopic = function(value) { - return jspb.Message.setField(this, 4, value); +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); }; /** - * Clears the field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.clearDeadLetterTopic = function() { - return jspb.Message.setField(this, 4, undefined); +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 4, value); }; /** - * Returns whether this field is set. - * @return {boolean} + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestInitialAlpha1.prototype.hasDeadLetterTopic = function() { - return jspb.Message.getField(this, 4) != null; +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); }; +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this + */ +proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + @@ -6472,8 +11249,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.InvokeActorResponse.toObject(opt_includeInstance, this); }; @@ -6482,14 +11259,13 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.InvokeActorResponse.toObject = function(includeInstance, msg) { var f, obj = { - id: jspb.Message.getFieldWithDefault(msg, 1, ""), - status: (f = msg.getStatus()) && dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.toObject(includeInstance, f) + data: msg.getData_asB64() }; if (includeInstance) { @@ -6503,23 +11279,23 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.toObject /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} + * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1; - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.InvokeActorResponse; + return proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} + * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -6527,13 +11303,8 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deseriali var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setId(value); - break; - case 2: - var value = new dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse; - reader.readMessage(value,dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.deserializeBinaryFromReader); - msg.setStatus(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setData(value); break; default: reader.skipField(); @@ -6548,9 +11319,9 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.deseriali * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.InvokeActorResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -6558,112 +11329,65 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} message + * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.InvokeActorResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getId(); + f = message.getData_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 1, f ); } - f = message.getStatus(); - if (f != null) { - writer.writeMessage( - 2, - f, - dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse.serializeBinaryToWriter - ); - } -}; - - -/** - * optional string id = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.getId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this + * optional bytes data = 1; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.setId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional TopicEventResponse status = 2; - * @return {?proto.dapr.proto.runtime.v1.TopicEventResponse} + * optional bytes data = 1; + * This is a type-conversion wrapper around `getData()` + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.getStatus = function() { - return /** @type{?proto.dapr.proto.runtime.v1.TopicEventResponse} */ ( - jspb.Message.getWrapperField(this, dapr_proto_runtime_v1_appcallback_pb.TopicEventResponse, 2)); -}; - - -/** - * @param {?proto.dapr.proto.runtime.v1.TopicEventResponse|undefined} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this -*/ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.setStatus = function(value) { - return jspb.Message.setWrapperField(this, 2, value); +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getData())); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1} returns this + * optional bytes data = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.clearStatus = function() { - return this.setStatus(undefined); +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getData())); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} returns this */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsRequestProcessedAlpha1.prototype.hasStatus = function() { - return jspb.Message.getField(this, 2) != null; +proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.setData = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; -/** - * Oneof group definitions for this message. Each group defines the field - * numbers belonging to that group. When of these fields' value is set, all - * other fields in the group are cleared. During deserialization, if multiple - * fields are encountered for a group, only the last value seen will be kept. - * @private {!Array>} - * @const - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_ = [[1,2]]; - -/** - * @enum {number} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase = { - SUBSCRIBE_TOPIC_EVENTS_RESPONSE_TYPE_NOT_SET: 0, - INITIAL_RESPONSE: 1, - EVENT_MESSAGE: 2 -}; - -/** - * @return {proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getSubscribeTopicEventsResponseTypeCase = function() { - return /** @type {proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.SubscribeTopicEventsResponseTypeCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0])); -}; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -6679,8 +11403,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetMetadataRequest.toObject(opt_includeInstance, this); }; @@ -6689,14 +11413,13 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.toObjec * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetMetadataRequest.toObject = function(includeInstance, msg) { var f, obj = { - initialResponse: (f = msg.getInitialResponse()) && proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject(includeInstance, f), - eventMessage: (f = msg.getEventMessage()) && dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.toObject(includeInstance, f) + }; if (includeInstance) { @@ -6710,39 +11433,29 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.toObject = functi /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} + * @return {!proto.dapr.proto.runtime.v1.GetMetadataRequest} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1; - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetMetadataRequest; + return proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} + * @return {!proto.dapr.proto.runtime.v1.GetMetadataRequest} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { - case 1: - var value = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1; - reader.readMessage(value,proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader); - msg.setInitialResponse(value); - break; - case 2: - var value = new dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest; - reader.readMessage(value,dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.deserializeBinaryFromReader); - msg.setEventMessage(value); - break; default: reader.skipField(); break; @@ -6756,9 +11469,9 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.deserializeBinary * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetMetadataRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -6766,105 +11479,22 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.seriali /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} message + * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetMetadataRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInitialResponse(); - if (f != null) { - writer.writeMessage( - 1, - f, - proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter - ); - } - f = message.getEventMessage(); - if (f != null) { - writer.writeMessage( - 2, - f, - dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest.serializeBinaryToWriter - ); - } -}; - - -/** - * optional SubscribeTopicEventsResponseInitialAlpha1 initial_response = 1; - * @return {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getInitialResponse = function() { - return /** @type{?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1, 1)); -}; - - -/** - * @param {?proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1|undefined} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this -*/ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.setInitialResponse = function(value) { - return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0], value); -}; - - -/** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.clearInitialResponse = function() { - return this.setInitialResponse(undefined); -}; - - -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.hasInitialResponse = function() { - return jspb.Message.getField(this, 1) != null; -}; - - -/** - * optional TopicEventRequest event_message = 2; - * @return {?proto.dapr.proto.runtime.v1.TopicEventRequest} - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.getEventMessage = function() { - return /** @type{?proto.dapr.proto.runtime.v1.TopicEventRequest} */ ( - jspb.Message.getWrapperField(this, dapr_proto_runtime_v1_appcallback_pb.TopicEventRequest, 2)); -}; - - -/** - * @param {?proto.dapr.proto.runtime.v1.TopicEventRequest|undefined} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this -*/ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.setEventMessage = function(value) { - return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.oneofGroups_[0], value); }; -/** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1} returns this - */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.clearEventMessage = function() { - return this.setEventMessage(undefined); -}; - /** - * Returns whether this field is set. - * @return {boolean} + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.prototype.hasEventMessage = function() { - return jspb.Message.getField(this, 2) != null; -}; - - +proto.dapr.proto.runtime.v1.GetMetadataResponse.repeatedFields_ = [2,3,5,6,9]; @@ -6881,8 +11511,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetMetadataResponse.toObject(opt_includeInstance, this); }; @@ -6891,13 +11521,27 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype. * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetMetadataResponse.toObject = function(includeInstance, msg) { var f, obj = { - + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + activeActorsCountList: jspb.Message.toObjectList(msg.getActiveActorsCountList(), + proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject, includeInstance), + registeredComponentsList: jspb.Message.toObjectList(msg.getRegisteredComponentsList(), + proto.dapr.proto.runtime.v1.RegisteredComponents.toObject, includeInstance), + extendedMetadataMap: (f = msg.getExtendedMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + subscriptionsList: jspb.Message.toObjectList(msg.getSubscriptionsList(), + proto.dapr.proto.runtime.v1.PubsubSubscription.toObject, includeInstance), + httpEndpointsList: jspb.Message.toObjectList(msg.getHttpEndpointsList(), + proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject, includeInstance), + appConnectionProperties: (f = msg.getAppConnectionProperties()) && proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject(includeInstance, f), + runtimeVersion: jspb.Message.getFieldWithDefault(msg, 8, ""), + enabledFeaturesList: (f = jspb.Message.getRepeatedField(msg, 9)) == null ? undefined : f, + actorRuntime: (f = msg.getActorRuntime()) && proto.dapr.proto.runtime.v1.ActorRuntime.toObject(includeInstance, f), + scheduler: (f = msg.getScheduler()) && proto.dapr.proto.runtime.v1.MetadataScheduler.toObject(includeInstance, f) }; if (includeInstance) { @@ -6911,29 +11555,82 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.toObject = /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1; - return proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetMetadataResponse; + return proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ActiveActorsCount; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader); + msg.addActiveActorsCount(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.RegisteredComponents; + reader.readMessage(value,proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader); + msg.addRegisteredComponents(value); + break; + case 4: + var value = msg.getExtendedMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 5: + var value = new proto.dapr.proto.runtime.v1.PubsubSubscription; + reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader); + msg.addSubscriptions(value); + break; + case 6: + var value = new proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint; + reader.readMessage(value,proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader); + msg.addHttpEndpoints(value); + break; + case 7: + var value = new proto.dapr.proto.runtime.v1.AppConnectionProperties; + reader.readMessage(value,proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader); + msg.setAppConnectionProperties(value); + break; + case 8: + var value = /** @type {string} */ (reader.readString()); + msg.setRuntimeVersion(value); + break; + case 9: + var value = /** @type {string} */ (reader.readString()); + msg.addEnabledFeatures(value); + break; + case 10: + var value = new proto.dapr.proto.runtime.v1.ActorRuntime; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader); + msg.setActorRuntime(value); + break; + case 11: + var value = new proto.dapr.proto.runtime.v1.MetadataScheduler; + reader.readMessage(value,proto.dapr.proto.runtime.v1.MetadataScheduler.deserializeBinaryFromReader); + msg.setScheduler(value); + break; default: reader.skipField(); break; @@ -6947,9 +11644,9 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.deserializ * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetMetadataResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -6957,452 +11654,462 @@ proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.prototype. /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1} message + * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeTopicEventsResponseInitialAlpha1.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetMetadataResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getActiveActorsCountList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter + ); + } + f = message.getRegisteredComponentsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter + ); + } + f = message.getExtendedMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = message.getSubscriptionsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 5, + f, + proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter + ); + } + f = message.getHttpEndpointsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 6, + f, + proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter + ); + } + f = message.getAppConnectionProperties(); + if (f != null) { + writer.writeMessage( + 7, + f, + proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter + ); + } + f = message.getRuntimeVersion(); + if (f.length > 0) { + writer.writeString( + 8, + f + ); + } + f = message.getEnabledFeaturesList(); + if (f.length > 0) { + writer.writeRepeatedString( + 9, + f + ); + } + f = message.getActorRuntime(); + if (f != null) { + writer.writeMessage( + 10, + f, + proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter + ); + } + f = message.getScheduler(); + if (f != null) { + writer.writeMessage( + 11, + f, + proto.dapr.proto.runtime.v1.MetadataScheduler.serializeBinaryToWriter + ); + } }; +/** + * optional string id = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * repeated ActiveActorsCount active_actors_count = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getActiveActorsCountList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ActiveActorsCount, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setActiveActorsCountList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addActiveActorsCount = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ActiveActorsCount, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearActiveActorsCountList = function() { + return this.setActiveActorsCountList([]); +}; + + +/** + * repeated RegisteredComponents registered_components = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getRegisteredComponentsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.RegisteredComponents, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setRegisteredComponentsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} + */ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addRegisteredComponents = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.RegisteredComponents, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.InvokeBindingRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearRegisteredComponentsList = function() { + return this.setRegisteredComponentsList([]); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * map extended_metadata = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.toObject = function(includeInstance, msg) { - var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, ""), - data: msg.getData_asB64(), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], - operation: jspb.Message.getFieldWithDefault(msg, 4, "") - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getExtendedMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.InvokeBindingRequest; - return proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinaryFromReader(msg, reader); -}; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearExtendedMetadataMap = function() { + this.getExtendedMetadataMap().clear(); + return this;}; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} + * repeated PubsubSubscription subscriptions = 5; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setOperation(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getSubscriptionsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscription, 5)); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.InvokeBindingRequest.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setSubscriptionsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 5, value); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } - f = message.getOperation(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addSubscriptions = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 5, opt_value, proto.dapr.proto.runtime.v1.PubsubSubscription, opt_index); }; /** - * optional string name = 1; - * @return {string} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearSubscriptionsList = function() { + return this.setSubscriptionsList([]); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + * repeated MetadataHTTPEndpoint http_endpoints = 6; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getHttpEndpointsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint, 6)); }; /** - * optional bytes data = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setHttpEndpointsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 6, value); }; /** - * optional bytes data = 2; - * This is a type-conversion wrapper around `getData()` - * @return {string} + * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addHttpEndpoints = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 6, opt_value, proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint, opt_index); }; /** - * optional bytes data = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearHttpEndpointsList = function() { + return this.setHttpEndpointsList([]); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + * optional AppConnectionProperties app_connection_properties = 7; + * @return {?proto.dapr.proto.runtime.v1.AppConnectionProperties} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getAppConnectionProperties = function() { + return /** @type{?proto.dapr.proto.runtime.v1.AppConnectionProperties} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.AppConnectionProperties, 7)); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * @param {?proto.dapr.proto.runtime.v1.AppConnectionProperties|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setAppConnectionProperties = function(value) { + return jspb.Message.setWrapperField(this, 7, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearAppConnectionProperties = function() { + return this.setAppConnectionProperties(undefined); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.hasAppConnectionProperties = function() { + return jspb.Message.getField(this, 7) != null; }; /** - * optional string operation = 4; + * optional string runtime_version = 8; * @return {string} */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.getOperation = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getRuntimeVersion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 8, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingRequest.prototype.setOperation = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setRuntimeVersion = function(value) { + return jspb.Message.setProto3StringField(this, 8, value); }; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * repeated string enabled_features = 9; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.InvokeBindingResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getEnabledFeaturesList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 9)); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.toObject = function(includeInstance, msg) { - var f, obj = { - data: msg.getData_asB64(), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setEnabledFeaturesList = function(value) { + return jspb.Message.setField(this, 9, value || []); }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} + * @param {string} value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.InvokeBindingResponse; - return proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addEnabledFeatures = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 9, value, opt_index); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 2: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); - break; - default: - reader.skipField(); - break; - } - } - return msg; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearEnabledFeaturesList = function() { + return this.setEnabledFeaturesList([]); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * optional ActorRuntime actor_runtime = 10; + * @return {?proto.dapr.proto.runtime.v1.ActorRuntime} */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.InvokeBindingResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getActorRuntime = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ActorRuntime} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ActorRuntime, 10)); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 1, - f - ); - } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } + * @param {?proto.dapr.proto.runtime.v1.ActorRuntime|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setActorRuntime = function(value) { + return jspb.Message.setWrapperField(this, 10, value); }; /** - * optional bytes data = 1; - * @return {!(string|Uint8Array)} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearActorRuntime = function() { + return this.setActorRuntime(undefined); }; /** - * optional bytes data = 1; - * This is a type-conversion wrapper around `getData()` - * @return {string} + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.hasActorRuntime = function() { + return jspb.Message.getField(this, 10) != null; }; /** - * optional bytes data = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * optional MetadataScheduler scheduler = 11; + * @return {?proto.dapr.proto.runtime.v1.MetadataScheduler} */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getScheduler = function() { + return /** @type{?proto.dapr.proto.runtime.v1.MetadataScheduler} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.MetadataScheduler, 11)); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} returns this - */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); + * @param {?proto.dapr.proto.runtime.v1.MetadataScheduler|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setScheduler = function(value) { + return jspb.Message.setWrapperField(this, 11, value); }; /** - * map metadata = 2; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 2, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearScheduler = function() { + return this.setScheduler(undefined); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.InvokeBindingResponse} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.InvokeBindingResponse.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.hasScheduler = function() { + return jspb.Message.getField(this, 11) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.MetadataScheduler.repeatedFields_ = [1]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -7418,8 +12125,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetSecretRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.MetadataScheduler.toObject(opt_includeInstance, this); }; @@ -7428,15 +12135,13 @@ proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.toObject = function(opt_i * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.MetadataScheduler} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetSecretRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.MetadataScheduler.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - key: jspb.Message.getFieldWithDefault(msg, 2, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + connectedAddressesList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f }; if (includeInstance) { @@ -7450,23 +12155,23 @@ proto.dapr.proto.runtime.v1.GetSecretRequest.toObject = function(includeInstance /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} + * @return {!proto.dapr.proto.runtime.v1.MetadataScheduler} */ -proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.MetadataScheduler.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetSecretRequest; - return proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.MetadataScheduler; + return proto.dapr.proto.runtime.v1.MetadataScheduler.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.MetadataScheduler} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} + * @return {!proto.dapr.proto.runtime.v1.MetadataScheduler} */ -proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.MetadataScheduler.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -7475,17 +12180,7 @@ proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader = funct switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + msg.addConnectedAddresses(value); break; default: reader.skipField(); @@ -7500,9 +12195,9 @@ proto.dapr.proto.runtime.v1.GetSecretRequest.deserializeBinaryFromReader = funct * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetSecretRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.MetadataScheduler.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -7510,92 +12205,66 @@ proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.serializeBinary = functio /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetSecretRequest} message + * @param {!proto.dapr.proto.runtime.v1.MetadataScheduler} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetSecretRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.MetadataScheduler.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getConnectedAddressesList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedString( 1, f ); } - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } -}; - - -/** - * optional string store_name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this + * repeated string connected_addresses = 1; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.getConnectedAddressesList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); }; /** - * optional string key = 2; - * @return {string} + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.MetadataScheduler} returns this */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.setConnectedAddressesList = function(value) { + return jspb.Message.setField(this, 1, value || []); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.MetadataScheduler} returns this */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.addConnectedAddresses = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.MetadataScheduler} returns this */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.MetadataScheduler.prototype.clearConnectedAddressesList = function() { + return this.setConnectedAddressesList([]); }; + /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetSecretRequest} returns this + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.GetSecretRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; -}; - - +proto.dapr.proto.runtime.v1.ActorRuntime.repeatedFields_ = [2]; @@ -7612,8 +12281,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetSecretResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ActorRuntime.toObject(opt_includeInstance, this); }; @@ -7622,13 +12291,17 @@ proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.toObject = function(opt_ * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetSecretResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ActorRuntime.toObject = function(includeInstance, msg) { var f, obj = { - dataMap: (f = msg.getDataMap()) ? f.toObject(includeInstance, undefined) : [] + runtimeStatus: jspb.Message.getFieldWithDefault(msg, 1, 0), + activeActorsList: jspb.Message.toObjectList(msg.getActiveActorsList(), + proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject, includeInstance), + hostReady: jspb.Message.getBooleanFieldWithDefault(msg, 3, false), + placement: jspb.Message.getFieldWithDefault(msg, 4, "") }; if (includeInstance) { @@ -7642,23 +12315,23 @@ proto.dapr.proto.runtime.v1.GetSecretResponse.toObject = function(includeInstanc /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} */ -proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetSecretResponse; - return proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ActorRuntime; + return proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} */ -proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -7666,10 +12339,21 @@ proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader = func var field = reader.getFieldNumber(); switch (field) { case 1: - var value = msg.getDataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} */ (reader.readEnum()); + msg.setRuntimeStatus(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ActiveActorsCount; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader); + msg.addActiveActors(value); + break; + case 3: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setHostReady(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setPlacement(value); break; default: reader.skipField(); @@ -7684,9 +12368,9 @@ proto.dapr.proto.runtime.v1.GetSecretResponse.deserializeBinaryFromReader = func * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetSecretResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -7694,39 +12378,142 @@ proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.serializeBinary = functi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetSecretResponse} message + * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetSecretResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getDataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getRuntimeStatus(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getActiveActorsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter + ); + } + f = message.getHostReady(); + if (f) { + writer.writeBool( + 3, + f + ); + } + f = message.getPlacement(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); } }; /** - * map data = 1; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * @enum {number} */ -proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.getDataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 1, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus = { + INITIALIZING: 0, + DISABLED: 1, + RUNNING: 2 +}; + +/** + * optional ActorRuntimeStatus runtime_status = 1; + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getRuntimeStatus = function() { + return /** @type {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetSecretResponse} returns this + * @param {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} value + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this */ -proto.dapr.proto.runtime.v1.GetSecretResponse.prototype.clearDataMap = function() { - this.getDataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setRuntimeStatus = function(value) { + return jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * repeated ActiveActorsCount active_actors = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getActiveActorsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ActiveActorsCount, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this +*/ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setActiveActorsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.addActiveActors = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ActiveActorsCount, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.clearActiveActorsList = function() { + return this.setActiveActorsList([]); +}; + + +/** + * optional bool host_ready = 3; + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getHostReady = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 3, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setHostReady = function(value) { + return jspb.Message.setProto3BooleanField(this, 3, value); +}; + + +/** + * optional string placement = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getPlacement = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + */ +proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setPlacement = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; @@ -7746,8 +12533,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetBulkSecretRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject(opt_includeInstance, this); }; @@ -7756,14 +12543,14 @@ proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + type: jspb.Message.getFieldWithDefault(msg, 1, ""), + count: jspb.Message.getFieldWithDefault(msg, 2, 0) }; if (includeInstance) { @@ -7777,23 +12564,23 @@ proto.dapr.proto.runtime.v1.GetBulkSecretRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetBulkSecretRequest; - return proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ActiveActorsCount; + return proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -7802,13 +12589,11 @@ proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setType(value); break; case 2: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {number} */ (reader.readInt32()); + msg.setCount(value); break; default: reader.skipField(); @@ -7823,9 +12608,9 @@ proto.dapr.proto.runtime.v1.GetBulkSecretRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetBulkSecretRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -7833,67 +12618,72 @@ proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} message + * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getType(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getCount(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); } }; /** - * optional string store_name = 1; + * optional string type = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.getStoreName = function() { +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.getType = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} returns this */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.setStoreName = function(value) { +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.setType = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * map metadata = 2; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional int32 count = 2; + * @return {number} */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 2, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.getCount = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} returns this + */ +proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.setCount = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); }; + /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretRequest} returns this + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.GetBulkSecretRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; -}; - - +proto.dapr.proto.runtime.v1.RegisteredComponents.repeatedFields_ = [4]; @@ -7910,8 +12700,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SecretResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SecretResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.RegisteredComponents.toObject(opt_includeInstance, this); }; @@ -7920,13 +12710,16 @@ proto.dapr.proto.runtime.v1.SecretResponse.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SecretResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SecretResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.RegisteredComponents.toObject = function(includeInstance, msg) { var f, obj = { - secretsMap: (f = msg.getSecretsMap()) ? f.toObject(includeInstance, undefined) : [] + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + type: jspb.Message.getFieldWithDefault(msg, 2, ""), + version: jspb.Message.getFieldWithDefault(msg, 3, ""), + capabilitiesList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? undefined : f }; if (includeInstance) { @@ -7940,23 +12733,23 @@ proto.dapr.proto.runtime.v1.SecretResponse.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SecretResponse} + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} */ -proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SecretResponse; - return proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.RegisteredComponents; + return proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SecretResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SecretResponse} + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} */ -proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -7964,10 +12757,20 @@ proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = msg.getSecretsMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setType(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setVersion(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.addCapabilities(value); break; default: reader.skipField(); @@ -7982,9 +12785,9 @@ proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SecretResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -7992,39 +12795,131 @@ proto.dapr.proto.runtime.v1.SecretResponse.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SecretResponse} message + * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getSecretsMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getType(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getVersion(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getCapabilitiesList(); + if (f.length > 0) { + writer.writeRepeatedString( + 4, + f + ); } }; /** - * map secrets = 1; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SecretResponse.prototype.getSecretsMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 1, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.SecretResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this */ -proto.dapr.proto.runtime.v1.SecretResponse.prototype.clearSecretsMap = function() { - this.getSecretsMap().clear(); - return this; +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string type = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getType = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setType = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string version = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getVersion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setVersion = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * repeated string capabilities = 4; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getCapabilitiesList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 4)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setCapabilitiesList = function(value) { + return jspb.Message.setField(this, 4, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.addCapabilities = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 4, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + */ +proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.clearCapabilitiesList = function() { + return this.setCapabilitiesList([]); }; @@ -8044,8 +12939,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetBulkSecretResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject(opt_includeInstance, this); }; @@ -8054,13 +12949,13 @@ proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject = function(includeInstance, msg) { var f, obj = { - dataMap: (f = msg.getDataMap()) ? f.toObject(includeInstance, proto.dapr.proto.runtime.v1.SecretResponse.toObject) : [] + name: jspb.Message.getFieldWithDefault(msg, 1, "") }; if (includeInstance) { @@ -8074,23 +12969,23 @@ proto.dapr.proto.runtime.v1.GetBulkSecretResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} + * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetBulkSecretResponse; - return proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint; + return proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} + * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -8098,10 +12993,8 @@ proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = msg.getDataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.runtime.v1.SecretResponse.deserializeBinaryFromReader, "", new proto.dapr.proto.runtime.v1.SecretResponse()); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; default: reader.skipField(); @@ -8116,9 +13009,9 @@ proto.dapr.proto.runtime.v1.GetBulkSecretResponse.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetBulkSecretResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -8126,39 +13019,37 @@ proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} message + * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getDataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.runtime.v1.SecretResponse.serializeBinaryToWriter); + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); } }; /** - * map data = 1; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.getDataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 1, opt_noLazyCreate, - proto.dapr.proto.runtime.v1.SecretResponse)); +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetBulkSecretResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} returns this */ -proto.dapr.proto.runtime.v1.GetBulkSecretResponse.prototype.clearDataMap = function() { - this.getDataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; @@ -8178,8 +13069,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject(opt_includeInstance, this); }; @@ -8188,14 +13079,17 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.toObject = fun * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject = function(includeInstance, msg) { var f, obj = { - operationtype: jspb.Message.getFieldWithDefault(msg, 1, ""), - request: (f = msg.getRequest()) && dapr_proto_common_v1_common_pb.StateItem.toObject(includeInstance, f) + port: jspb.Message.getFieldWithDefault(msg, 1, 0), + protocol: jspb.Message.getFieldWithDefault(msg, 2, ""), + channelAddress: jspb.Message.getFieldWithDefault(msg, 3, ""), + maxConcurrency: jspb.Message.getFieldWithDefault(msg, 4, 0), + health: (f = msg.getHealth()) && proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject(includeInstance, f) }; if (includeInstance) { @@ -8209,23 +13103,23 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject = function(incl /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.TransactionalStateOperation; - return proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.AppConnectionProperties; + return proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -8233,13 +13127,25 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromRea var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setOperationtype(value); + var value = /** @type {number} */ (reader.readInt32()); + msg.setPort(value); break; case 2: - var value = new dapr_proto_common_v1_common_pb.StateItem; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StateItem.deserializeBinaryFromReader); - msg.setRequest(value); + var value = /** @type {string} */ (reader.readString()); + msg.setProtocol(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setChannelAddress(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxConcurrency(value); + break; + case 5: + var value = new proto.dapr.proto.runtime.v1.AppConnectionHealthProperties; + reader.readMessage(value,proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader); + msg.setHealth(value); break; default: reader.skipField(); @@ -8254,9 +13160,9 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromRea * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -8264,73 +13170,148 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.serializeBinar /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} message + * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getOperationtype(); + f = message.getPort(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getProtocol(); if (f.length > 0) { writer.writeString( - 1, + 2, f ); } - f = message.getRequest(); + f = message.getChannelAddress(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getMaxConcurrency(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } + f = message.getHealth(); if (f != null) { writer.writeMessage( - 2, + 5, f, - dapr_proto_common_v1_common_pb.StateItem.serializeBinaryToWriter + proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter ); } }; /** - * optional string operationType = 1; + * optional int32 port = 1; + * @return {number} + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getPort = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setPort = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional string protocol = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.getOperationtype = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getProtocol = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.setOperationtype = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setProtocol = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional dapr.proto.common.v1.StateItem request = 2; - * @return {?proto.dapr.proto.common.v1.StateItem} + * optional string channel_address = 3; + * @return {string} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.getRequest = function() { - return /** @type{?proto.dapr.proto.common.v1.StateItem} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StateItem, 2)); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getChannelAddress = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * @param {?proto.dapr.proto.common.v1.StateItem|undefined} value - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setChannelAddress = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional int32 max_concurrency = 4; + * @return {number} + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getMaxConcurrency = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setMaxConcurrency = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional AppConnectionHealthProperties health = 5; + * @return {?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} + */ +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getHealth = function() { + return /** @type{?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.AppConnectionHealthProperties, 5)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties|undefined} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.setRequest = function(value) { - return jspb.Message.setWrapperField(this, 2, value); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setHealth = function(value) { + return jspb.Message.setWrapperField(this, 5, value); }; /** * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} returns this + * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.clearRequest = function() { - return this.setRequest(undefined); +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.clearHealth = function() { + return this.setHealth(undefined); }; @@ -8338,19 +13319,12 @@ proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.clearRequest = * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.TransactionalStateOperation.prototype.hasRequest = function() { - return jspb.Message.getField(this, 2) != null; +proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.hasHealth = function() { + return jspb.Message.getField(this, 5) != null; }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.repeatedFields_ = [2]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -8366,8 +13340,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject(opt_includeInstance, this); }; @@ -8376,16 +13350,16 @@ proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.toObject = * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject = function(includeInstance, msg) { var f, obj = { - storename: jspb.Message.getFieldWithDefault(msg, 1, ""), - operationsList: jspb.Message.toObjectList(msg.getOperationsList(), - proto.dapr.proto.runtime.v1.TransactionalStateOperation.toObject, includeInstance), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + healthCheckPath: jspb.Message.getFieldWithDefault(msg, 1, ""), + healthProbeInterval: jspb.Message.getFieldWithDefault(msg, 2, ""), + healthProbeTimeout: jspb.Message.getFieldWithDefault(msg, 3, ""), + healthThreshold: jspb.Message.getFieldWithDefault(msg, 4, 0) }; if (includeInstance) { @@ -8399,23 +13373,23 @@ proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.toObject = function(i /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest; - return proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.AppConnectionHealthProperties; + return proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -8424,18 +13398,19 @@ proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFrom switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStorename(value); + msg.setHealthCheckPath(value); break; case 2: - var value = new proto.dapr.proto.runtime.v1.TransactionalStateOperation; - reader.readMessage(value,proto.dapr.proto.runtime.v1.TransactionalStateOperation.deserializeBinaryFromReader); - msg.addOperations(value); + var value = /** @type {string} */ (reader.readString()); + msg.setHealthProbeInterval(value); break; case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setHealthProbeTimeout(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setHealthThreshold(value); break; default: reader.skipField(); @@ -8450,9 +13425,9 @@ proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.deserializeBinaryFrom * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -8460,110 +13435,112 @@ proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.serializeBi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} message + * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStorename(); + f = message.getHealthCheckPath(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getHealthProbeInterval(); if (f.length > 0) { writer.writeString( - 1, + 2, f ); } - f = message.getOperationsList(); + f = message.getHealthProbeTimeout(); if (f.length > 0) { - writer.writeRepeatedMessage( - 2, - f, - proto.dapr.proto.runtime.v1.TransactionalStateOperation.serializeBinaryToWriter + writer.writeString( + 3, + f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getHealthThreshold(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); } }; /** - * optional string storeName = 1; + * optional string health_check_path = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getStorename = function() { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthCheckPath = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.setStorename = function(value) { +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthCheckPath = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * repeated TransactionalStateOperation operations = 2; - * @return {!Array} + * optional string health_probe_interval = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getOperationsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.TransactionalStateOperation, 2)); +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthProbeInterval = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this -*/ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.setOperationsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this + */ +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthProbeInterval = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * @param {!proto.dapr.proto.runtime.v1.TransactionalStateOperation=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.TransactionalStateOperation} + * optional string health_probe_timeout = 3; + * @return {string} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.addOperations = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.TransactionalStateOperation, opt_index); +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthProbeTimeout = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.clearOperationsList = function() { - return this.setOperationsList([]); +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthProbeTimeout = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional int32 health_threshold = 4; + * @return {number} */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthThreshold = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest} returns this + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this */ -proto.dapr.proto.runtime.v1.ExecuteStateTransactionRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthThreshold = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); }; @@ -8583,8 +13560,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PubsubSubscription.toObject(opt_includeInstance, this); }; @@ -8593,20 +13570,18 @@ proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.toObject = funct * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.PubsubSubscription.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - name: jspb.Message.getFieldWithDefault(msg, 3, ""), - dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), - period: jspb.Message.getFieldWithDefault(msg, 5, ""), - callback: jspb.Message.getFieldWithDefault(msg, 6, ""), - data: msg.getData_asB64(), - ttl: jspb.Message.getFieldWithDefault(msg, 8, "") + pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), + topic: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + rules: (f = msg.getRules()) && proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject(includeInstance, f), + deadLetterTopic: jspb.Message.getFieldWithDefault(msg, 5, ""), + type: jspb.Message.getFieldWithDefault(msg, 6, 0) }; if (includeInstance) { @@ -8620,23 +13595,23 @@ proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.toObject = function(includ /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.RegisterActorTimerRequest; - return proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.PubsubSubscription; + return proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -8645,35 +13620,30 @@ proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReade switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setPubsubName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); + msg.setTopic(value); break; case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setDueTime(value); + var value = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRules; + reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader); + msg.setRules(value); break; case 5: var value = /** @type {string} */ (reader.readString()); - msg.setPeriod(value); + msg.setDeadLetterTopic(value); break; case 6: - var value = /** @type {string} */ (reader.readString()); - msg.setCallback(value); - break; - case 7: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 8: - var value = /** @type {string} */ (reader.readString()); - msg.setTtl(value); + var value = /** @type {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} */ (reader.readEnum()); + msg.setType(value); break; default: reader.skipField(); @@ -8688,9 +13658,9 @@ proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.deserializeBinaryFromReade * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -8698,236 +13668,343 @@ proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.serializeBinary /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} message + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getPubsubName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); + f = message.getTopic(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } - f = message.getDueTime(); - if (f.length > 0) { - writer.writeString( + f = message.getRules(); + if (f != null) { + writer.writeMessage( 4, - f + f, + proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter ); } - f = message.getPeriod(); + f = message.getDeadLetterTopic(); if (f.length > 0) { writer.writeString( 5, f ); } - f = message.getCallback(); - if (f.length > 0) { - writer.writeString( + f = message.getType(); + if (f !== 0.0) { + writer.writeEnum( 6, f ); } - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 7, - f - ); - } - f = message.getTtl(); - if (f.length > 0) { - writer.writeString( - 8, - f - ); - } }; /** - * optional string actor_type = 1; - * @return {string} + * optional string pubsub_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getPubsubName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setPubsubName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string topic = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setTopic = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + */ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + +/** + * optional PubsubSubscriptionRules rules = 4; + * @return {?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getActorType = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getRules = function() { + return /** @type{?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscriptionRules, 4)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this - */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setActorType = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); + * @param {?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules|undefined} value + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this +*/ +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setRules = function(value) { + return jspb.Message.setWrapperField(this, 4, value); }; /** - * optional string actor_id = 2; - * @return {string} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getActorId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.clearRules = function() { + return this.setRules(undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setActorId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.hasRules = function() { + return jspb.Message.getField(this, 4) != null; }; /** - * optional string name = 3; + * optional string dead_letter_topic = 5; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getDeadLetterTopic = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setDeadLetterTopic = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); }; /** - * optional string due_time = 4; - * @return {string} + * optional PubsubSubscriptionType type = 6; + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getDueTime = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getType = function() { + return /** @type {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} value + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setDueTime = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setType = function(value) { + return jspb.Message.setProto3EnumField(this, 6, value); }; + /** - * optional string period = 5; - * @return {string} + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getPeriod = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); -}; +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.repeatedFields_ = [1]; + +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setPeriod = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject(opt_includeInstance, this); }; /** - * optional string callback = 6; - * @return {string} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getCallback = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject = function(includeInstance, msg) { + var f, obj = { + rulesList: jspb.Message.toObjectList(msg.getRulesList(), + proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setCallback = function(value) { - return jspb.Message.setProto3StringField(this, 6, value); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRules; + return proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader(msg, reader); }; /** - * optional bytes data = 7; - * @return {!(string|Uint8Array)} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRule; + reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader); + msg.addRules(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional bytes data = 7; - * This is a type-conversion wrapper around `getData()` - * @return {string} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * optional bytes data = 7; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRulesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter + ); + } }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * repeated PubsubSubscriptionRule rules = 1; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 7, value); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.getRulesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscriptionRule, 1)); }; /** - * optional string ttl = 8; - * @return {string} + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} returns this +*/ +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.setRulesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.getTtl = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 8, "")); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.addRules = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.PubsubSubscriptionRule, opt_index); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorTimerRequest} returns this + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorTimerRequest.prototype.setTtl = function(value) { - return jspb.Message.setProto3StringField(this, 8, value); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.clearRulesList = function() { + return this.setRulesList([]); }; @@ -8947,8 +14024,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject(opt_includeInstance, this); }; @@ -8957,15 +14034,14 @@ proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.toObject = fun * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - name: jspb.Message.getFieldWithDefault(msg, 3, "") + match: jspb.Message.getFieldWithDefault(msg, 1, ""), + path: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -8979,23 +14055,23 @@ proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.toObject = function(incl /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest; - return proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRule; + return proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -9004,15 +14080,11 @@ proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromRea switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setMatch(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + msg.setPath(value); break; default: reader.skipField(); @@ -9027,9 +14099,9 @@ proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.deserializeBinaryFromRea * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -9037,90 +14109,65 @@ proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.serializeBinar /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} message + * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getMatch(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); + f = message.getPath(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } }; /** - * optional string actor_type = 1; + * optional string match = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getActorType = function() { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.getMatch = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} returns this */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setActorType = function(value) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.setMatch = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string actor_id = 2; + * optional string path = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getActorId = function() { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.getPath = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} returns this */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setActorId = function(value) { +proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.setPath = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; -/** - * optional string name = 3; - * @return {string} - */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest} returns this - */ -proto.dapr.proto.runtime.v1.UnregisterActorTimerRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - @@ -9137,8 +14184,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SetMetadataRequest.toObject(opt_includeInstance, this); }; @@ -9147,19 +14194,14 @@ proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.toObject = fu * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - name: jspb.Message.getFieldWithDefault(msg, 3, ""), - dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), - period: jspb.Message.getFieldWithDefault(msg, 5, ""), - data: msg.getData_asB64(), - ttl: jspb.Message.getFieldWithDefault(msg, 7, "") + key: jspb.Message.getFieldWithDefault(msg, 1, ""), + value: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -9173,23 +14215,23 @@ proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.toObject = function(inc /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} + * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.RegisterActorReminderRequest; - return proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SetMetadataRequest; + return proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} + * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -9198,31 +14240,11 @@ proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromRe switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setKey(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setDueTime(value); - break; - case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setPeriod(value); - break; - case 6: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 7: - var value = /** @type {string} */ (reader.readString()); - msg.setTtl(value); + msg.setValue(value); break; default: reader.skipField(); @@ -9237,9 +14259,9 @@ proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.deserializeBinaryFromRe * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SetMetadataRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -9247,212 +14269,282 @@ proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.serializeBina /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} message + * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getKey(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); + f = message.getValue(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getDueTime(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } - f = message.getPeriod(); - if (f.length > 0) { - writer.writeString( - 5, - f - ); - } - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 6, - f - ); - } - f = message.getTtl(); - if (f.length > 0) { - writer.writeString( - 7, - f - ); - } }; /** - * optional string actor_type = 1; + * optional string key = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getActorType = function() { +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.getKey = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setActorType = function(value) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.setKey = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string actor_id = 2; + * optional string value = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getActorId = function() { +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.getValue = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setActorId = function(value) { +proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.setValue = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; + /** - * optional string name = 3; - * @return {string} + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.repeatedFields_ = [2]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetConfigurationRequest.toObject(opt_includeInstance, this); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.toObject = function(includeInstance, msg) { + var f, obj = { + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} + */ +proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.GetConfigurationRequest; + return proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} + */ +proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.addKeys(value); + break; + case 3: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional string due_time = 4; - * @return {string} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getDueTime = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.GetConfigurationRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setDueTime = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getKeysList(); + if (f.length > 0) { + writer.writeRepeatedString( + 2, + f + ); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * optional string period = 5; + * optional string store_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getPeriod = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setPeriod = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes data = 6; - * @return {!(string|Uint8Array)} + * repeated string keys = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getKeysList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); }; /** - * optional bytes data = 6; - * This is a type-conversion wrapper around `getData()` - * @return {string} + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.setKeysList = function(value) { + return jspb.Message.setField(this, 2, value || []); }; /** - * optional bytes data = 6; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * @param {string} value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.addKeys = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 2, value, opt_index); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 6, value); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.clearKeysList = function() { + return this.setKeysList([]); }; /** - * optional string ttl = 7; - * @return {string} + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.getTtl = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisterActorReminderRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisterActorReminderRequest.prototype.setTtl = function(value) { - return jspb.Message.setProto3StringField(this, 7, value); -}; +proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; @@ -9471,8 +14563,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetConfigurationResponse.toObject(opt_includeInstance, this); }; @@ -9481,15 +14573,13 @@ proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.toObject = * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetConfigurationResponse.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - name: jspb.Message.getFieldWithDefault(msg, 3, "") + itemsMap: (f = msg.getItemsMap()) ? f.toObject(includeInstance, proto.dapr.proto.common.v1.ConfigurationItem.toObject) : [] }; if (includeInstance) { @@ -9503,23 +14593,23 @@ proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.toObject = function(i /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest; - return proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetConfigurationResponse; + return proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -9527,16 +14617,10 @@ proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFrom var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + var value = msg.getItemsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.common.v1.ConfigurationItem.deserializeBinaryFromReader, "", new proto.dapr.proto.common.v1.ConfigurationItem()); + }); break; default: reader.skipField(); @@ -9551,9 +14635,9 @@ proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.deserializeBinaryFrom * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetConfigurationResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -9561,90 +14645,48 @@ proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.serializeBi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} message + * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetConfigurationResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getActorId(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); + f = message.getItemsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.common.v1.ConfigurationItem.serializeBinaryToWriter); } }; /** - * optional string actor_type = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getActorType = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this - */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setActorType = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string actor_id = 2; - * @return {string} + * map items = 1; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getActorId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.getItemsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 1, opt_noLazyCreate, + proto.dapr.proto.common.v1.ConfigurationItem)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} returns this */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setActorId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - +proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.clearItemsMap = function() { + this.getItemsMap().clear(); + return this;}; -/** - * optional string name = 3; - * @return {string} - */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest} returns this + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.UnregisterActorReminderRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.repeatedFields_ = [2]; @@ -9661,8 +14703,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetActorStateRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.toObject(opt_includeInstance, this); }; @@ -9671,15 +14713,15 @@ proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - key: jspb.Message.getFieldWithDefault(msg, 3, "") + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -9693,23 +14735,23 @@ proto.dapr.proto.runtime.v1.GetActorStateRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetActorStateRequest; - return proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest; + return proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -9718,15 +14760,17 @@ proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setStoreName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); + msg.addKeys(value); break; case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; default: reader.skipField(); @@ -9741,9 +14785,9 @@ proto.dapr.proto.runtime.v1.GetActorStateRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetActorStateRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -9751,90 +14795,110 @@ proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetActorStateRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getStoreName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); + f = message.getKeysList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedString( 2, f ); } - f = message.getKey(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } }; /** - * optional string actor_type = 1; + * optional string store_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getActorType = function() { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getStoreName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setActorType = function(value) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.setStoreName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string actor_id = 2; - * @return {string} + * repeated string keys = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getActorId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getKeysList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.setKeysList = function(value) { + return jspb.Message.setField(this, 2, value || []); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setActorId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.addKeys = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 2, value, opt_index); }; /** - * optional string key = 3; - * @return {string} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.clearKeysList = function() { + return this.setKeysList([]); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetActorStateRequest} returns this + * map metadata = 3; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.GetActorStateRequest.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 3, opt_noLazyCreate, + null)); }; +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + @@ -9851,8 +14915,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetActorStateResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.toObject(opt_includeInstance, this); }; @@ -9861,14 +14925,14 @@ proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.toObject = function(includeInstance, msg) { var f, obj = { - data: msg.getData_asB64(), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + id: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -9882,23 +14946,23 @@ proto.dapr.proto.runtime.v1.GetActorStateResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetActorStateResponse; - return proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest; + return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -9906,14 +14970,12 @@ proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); break; case 2: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); break; default: reader.skipField(); @@ -9928,9 +14990,9 @@ proto.dapr.proto.runtime.v1.GetActorStateResponse.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetActorStateResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -9938,99 +15000,66 @@ proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetActorStateResponse} message + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getData_asU8(); + f = message.getStoreName(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 1, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); } }; /** - * optional bytes data = 1; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes data = 1; - * This is a type-conversion wrapper around `getData()` + * optional string store_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * map metadata = 2; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string id = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 2, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetActorStateResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} returns this */ -proto.dapr.proto.runtime.v1.GetActorStateResponse.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.repeatedFields_ = [3]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -10046,8 +15075,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.toObject(opt_includeInstance, this); }; @@ -10056,16 +15085,14 @@ proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.toObje * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.toObject = function(includeInstance, msg) { - var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - operationsList: jspb.Message.toObjectList(msg.getOperationsList(), - proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject, includeInstance) + */ +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.toObject = function(includeInstance, msg) { + var f, obj = { + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + itemsMap: (f = msg.getItemsMap()) ? f.toObject(includeInstance, proto.dapr.proto.common.v1.ConfigurationItem.toObject) : [] }; if (includeInstance) { @@ -10079,23 +15106,23 @@ proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.toObject = funct /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest; - return proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse; + return proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -10104,16 +15131,13 @@ proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinar switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setId(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); - break; - case 3: - var value = new proto.dapr.proto.runtime.v1.TransactionalActorStateOperation; - reader.readMessage(value,proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader); - msg.addOperations(value); + var value = msg.getItemsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.common.v1.ConfigurationItem.deserializeBinaryFromReader, "", new proto.dapr.proto.common.v1.ConfigurationItem()); + }); break; default: reader.skipField(); @@ -10128,9 +15152,9 @@ proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.deserializeBinar * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -10138,109 +15162,64 @@ proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.serial /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getOperationsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 3, - f, - proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter - ); + f = message.getItemsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.common.v1.ConfigurationItem.serializeBinaryToWriter); } }; /** - * optional string actor_type = 1; + * optional string id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getActorType = function() { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.getId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} returns this */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setActorType = function(value) { +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.setId = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string actor_id = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getActorId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this - */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setActorId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -/** - * repeated TransactionalActorStateOperation operations = 3; - * @return {!Array} - */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.getOperationsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.TransactionalActorStateOperation, 3)); -}; - - -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this -*/ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.setOperationsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 3, value); -}; - - -/** - * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} + * map items = 2; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.addOperations = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.TransactionalActorStateOperation, opt_index); +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.getItemsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 2, opt_noLazyCreate, + proto.dapr.proto.common.v1.ConfigurationItem)); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} returns this */ -proto.dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.prototype.clearOperationsList = function() { - return this.setOperationsList([]); -}; +proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.clearItemsMap = function() { + this.getItemsMap().clear(); + return this;}; @@ -10259,8 +15238,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.toObject(opt_includeInstance, this); }; @@ -10269,16 +15248,14 @@ proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.toObject * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.toObject = function(includeInstance, msg) { var f, obj = { - operationtype: jspb.Message.getFieldWithDefault(msg, 1, ""), - key: jspb.Message.getFieldWithDefault(msg, 2, ""), - value: (f = msg.getValue()) && google_protobuf_any_pb.Any.toObject(includeInstance, f), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + ok: jspb.Message.getBooleanFieldWithDefault(msg, 1, false), + message: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -10292,23 +15269,23 @@ proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.toObject = function /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.TransactionalActorStateOperation; - return proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse; + return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -10316,23 +15293,12 @@ proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFr var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setOperationtype(value); + var value = /** @type {boolean} */ (reader.readBool()); + msg.setOk(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 3: - var value = new google_protobuf_any_pb.Any; - reader.readMessage(value,google_protobuf_any_pb.Any.deserializeBinaryFromReader); - msg.setValue(value); - break; - case 4: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + msg.setMessage(value); break; default: reader.skipField(); @@ -10347,9 +15313,9 @@ proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.deserializeBinaryFr * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -10357,134 +15323,62 @@ proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.serialize /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} message + * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getOperationtype(); - if (f.length > 0) { - writer.writeString( + f = message.getOk(); + if (f) { + writer.writeBool( 1, f ); } - f = message.getKey(); + f = message.getMessage(); if (f.length > 0) { writer.writeString( 2, f - ); - } - f = message.getValue(); - if (f != null) { - writer.writeMessage( - 3, - f, - google_protobuf_any_pb.Any.serializeBinaryToWriter - ); - } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } -}; - - -/** - * optional string operationType = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getOperationtype = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this - */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setOperationtype = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string key = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this - */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -/** - * optional google.protobuf.Any value = 3; - * @return {?proto.google.protobuf.Any} - */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getValue = function() { - return /** @type{?proto.google.protobuf.Any} */ ( - jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 3)); -}; - - -/** - * @param {?proto.google.protobuf.Any|undefined} value - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this -*/ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.setValue = function(value) { - return jspb.Message.setWrapperField(this, 3, value); + ); + } }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this + * optional bool ok = 1; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.clearValue = function() { - return this.setValue(undefined); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.getOk = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} returns this */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.hasValue = function() { - return jspb.Message.getField(this, 3) != null; +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.setOk = function(value) { + return jspb.Message.setProto3BooleanField(this, 1, value); }; /** - * map metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string message = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.getMessage = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.TransactionalActorStateOperation} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} returns this */ -proto.dapr.proto.runtime.v1.TransactionalActorStateOperation.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.setMessage = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; @@ -10504,8 +15398,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.InvokeActorRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.TryLockRequest.toObject(opt_includeInstance, this); }; @@ -10514,17 +15408,16 @@ proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.TryLockRequest.toObject = function(includeInstance, msg) { var f, obj = { - actorType: jspb.Message.getFieldWithDefault(msg, 1, ""), - actorId: jspb.Message.getFieldWithDefault(msg, 2, ""), - method: jspb.Message.getFieldWithDefault(msg, 3, ""), - data: msg.getData_asB64(), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + resourceId: jspb.Message.getFieldWithDefault(msg, 2, ""), + lockOwner: jspb.Message.getFieldWithDefault(msg, 3, ""), + expiryInSeconds: jspb.Message.getFieldWithDefault(msg, 4, 0) }; if (includeInstance) { @@ -10538,23 +15431,23 @@ proto.dapr.proto.runtime.v1.InvokeActorRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.InvokeActorRequest; - return proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.TryLockRequest; + return proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -10563,25 +15456,19 @@ proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader = fun switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setActorType(value); + msg.setStoreName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setActorId(value); + msg.setResourceId(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setMethod(value); + msg.setLockOwner(value); break; case 4: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 5: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {number} */ (reader.readInt32()); + msg.setExpiryInSeconds(value); break; default: reader.skipField(); @@ -10596,9 +15483,9 @@ proto.dapr.proto.runtime.v1.InvokeActorRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.InvokeActorRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.TryLockRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -10606,163 +15493,112 @@ proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.InvokeActorRequest} message + * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.TryLockRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getActorType(); + f = message.getStoreName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getActorId(); + f = message.getResourceId(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getMethod(); + f = message.getLockOwner(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = message.getExpiryInSeconds(); + if (f !== 0) { + writer.writeInt32( 4, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string actor_type = 1; + * optional string store_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getActorType = function() { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getStoreName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setActorType = function(value) { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setStoreName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string actor_id = 2; + * optional string resource_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getActorId = function() { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getResourceId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setActorId = function(value) { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setResourceId = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional string method = 3; + * optional string lock_owner = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getMethod = function() { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getLockOwner = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setMethod = function(value) { +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setLockOwner = function(value) { return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional bytes data = 4; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * optional bytes data = 4; - * This is a type-conversion wrapper around `getData()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 4; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this - */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 4, value); -}; - - -/** - * map metadata = 5; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional int32 expiry_in_seconds = 4; + * @return {number} */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 5, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getExpiryInSeconds = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.InvokeActorRequest} returns this + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this */ -proto.dapr.proto.runtime.v1.InvokeActorRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setExpiryInSeconds = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); }; @@ -10782,8 +15618,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.InvokeActorResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.TryLockResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.TryLockResponse.toObject(opt_includeInstance, this); }; @@ -10792,13 +15628,13 @@ proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.TryLockResponse.toObject = function(includeInstance, msg) { var f, obj = { - data: msg.getData_asB64() + success: jspb.Message.getBooleanFieldWithDefault(msg, 1, false) }; if (includeInstance) { @@ -10812,23 +15648,23 @@ proto.dapr.proto.runtime.v1.InvokeActorResponse.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} + * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.InvokeActorResponse; - return proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.TryLockResponse; + return proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} + * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -10836,8 +15672,8 @@ proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader = fu var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); + var value = /** @type {boolean} */ (reader.readBool()); + msg.setSuccess(value); break; default: reader.skipField(); @@ -10852,9 +15688,9 @@ proto.dapr.proto.runtime.v1.InvokeActorResponse.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.TryLockResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.InvokeActorResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.TryLockResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -10862,61 +15698,37 @@ proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.InvokeActorResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 1, - f - ); - } -}; - - -/** - * optional bytes data = 1; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes data = 1; - * This is a type-conversion wrapper around `getData()` - * @return {string} + * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); +proto.dapr.proto.runtime.v1.TryLockResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSuccess(); + if (f) { + writer.writeBool( + 1, + f + ); + } }; /** - * optional bytes data = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} + * optional bool success = 1; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); +proto.dapr.proto.runtime.v1.TryLockResponse.prototype.getSuccess = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.InvokeActorResponse} returns this + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} returns this */ -proto.dapr.proto.runtime.v1.InvokeActorResponse.prototype.setData = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.TryLockResponse.prototype.setSuccess = function(value) { + return jspb.Message.setProto3BooleanField(this, 1, value); }; @@ -10936,8 +15748,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetMetadataRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnlockRequest.toObject(opt_includeInstance, this); }; @@ -10946,13 +15758,15 @@ proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnlockRequest.toObject = function(includeInstance, msg) { var f, obj = { - + storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), + resourceId: jspb.Message.getFieldWithDefault(msg, 2, ""), + lockOwner: jspb.Message.getFieldWithDefault(msg, 3, "") }; if (includeInstance) { @@ -10966,29 +15780,41 @@ proto.dapr.proto.runtime.v1.GetMetadataRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataRequest} + * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetMetadataRequest; - return proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.UnlockRequest; + return proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataRequest} + * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setStoreName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setResourceId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setLockOwner(value); + break; default: reader.skipField(); break; @@ -11002,9 +15828,9 @@ proto.dapr.proto.runtime.v1.GetMetadataRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetMetadataRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnlockRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -11012,22 +15838,90 @@ proto.dapr.proto.runtime.v1.GetMetadataRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetMetadataRequest} message + * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnlockRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; + f = message.getStoreName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getResourceId(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getLockOwner(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } }; +/** + * optional string store_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getStoreName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + /** - * List of repeated fields within this message type. - * @private {!Array} - * @const + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.repeatedFields_ = [2,3,5,6,9]; +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setStoreName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string resource_id = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getResourceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this + */ +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setResourceId = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string lock_owner = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getLockOwner = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this + */ +proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setLockOwner = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + @@ -11044,8 +15938,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetMetadataResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.UnlockResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.UnlockResponse.toObject(opt_includeInstance, this); }; @@ -11054,109 +15948,52 @@ proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.UnlockResponse.toObject = function(includeInstance, msg) { var f, obj = { - id: jspb.Message.getFieldWithDefault(msg, 1, ""), - activeActorsCountList: jspb.Message.toObjectList(msg.getActiveActorsCountList(), - proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject, includeInstance), - registeredComponentsList: jspb.Message.toObjectList(msg.getRegisteredComponentsList(), - proto.dapr.proto.runtime.v1.RegisteredComponents.toObject, includeInstance), - extendedMetadataMap: (f = msg.getExtendedMetadataMap()) ? f.toObject(includeInstance, undefined) : [], - subscriptionsList: jspb.Message.toObjectList(msg.getSubscriptionsList(), - proto.dapr.proto.runtime.v1.PubsubSubscription.toObject, includeInstance), - httpEndpointsList: jspb.Message.toObjectList(msg.getHttpEndpointsList(), - proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject, includeInstance), - appConnectionProperties: (f = msg.getAppConnectionProperties()) && proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject(includeInstance, f), - runtimeVersion: jspb.Message.getFieldWithDefault(msg, 8, ""), - enabledFeaturesList: (f = jspb.Message.getRepeatedField(msg, 9)) == null ? undefined : f, - actorRuntime: (f = msg.getActorRuntime()) && proto.dapr.proto.runtime.v1.ActorRuntime.toObject(includeInstance, f) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} - */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetMetadataResponse; - return proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} - */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setId(value); - break; - case 2: - var value = new proto.dapr.proto.runtime.v1.ActiveActorsCount; - reader.readMessage(value,proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader); - msg.addActiveActorsCount(value); - break; - case 3: - var value = new proto.dapr.proto.runtime.v1.RegisteredComponents; - reader.readMessage(value,proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader); - msg.addRegisteredComponents(value); - break; - case 4: - var value = msg.getExtendedMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); - break; - case 5: - var value = new proto.dapr.proto.runtime.v1.PubsubSubscription; - reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader); - msg.addSubscriptions(value); - break; - case 6: - var value = new proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint; - reader.readMessage(value,proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader); - msg.addHttpEndpoints(value); - break; - case 7: - var value = new proto.dapr.proto.runtime.v1.AppConnectionProperties; - reader.readMessage(value,proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader); - msg.setAppConnectionProperties(value); - break; - case 8: - var value = /** @type {string} */ (reader.readString()); - msg.setRuntimeVersion(value); - break; - case 9: - var value = /** @type {string} */ (reader.readString()); - msg.addEnabledFeatures(value); + status: jspb.Message.getFieldWithDefault(msg, 1, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} + */ +proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.UnlockResponse; + return proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} + */ +proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { break; - case 10: - var value = new proto.dapr.proto.runtime.v1.ActorRuntime; - reader.readMessage(value,proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader); - msg.setActorRuntime(value); + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} */ (reader.readEnum()); + msg.setStatus(value); break; default: reader.skipField(); @@ -11171,9 +16008,9 @@ proto.dapr.proto.runtime.v1.GetMetadataResponse.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.UnlockResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetMetadataResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.UnlockResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -11181,418 +16018,409 @@ proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetMetadataResponse} message + * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.UnlockResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getId(); - if (f.length > 0) { - writer.writeString( + f = message.getStatus(); + if (f !== 0.0) { + writer.writeEnum( 1, f ); } - f = message.getActiveActorsCountList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 2, - f, - proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter - ); - } - f = message.getRegisteredComponentsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 3, - f, - proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter - ); - } - f = message.getExtendedMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } - f = message.getSubscriptionsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 5, - f, - proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter - ); - } - f = message.getHttpEndpointsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( - 6, - f, - proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter - ); - } - f = message.getAppConnectionProperties(); - if (f != null) { - writer.writeMessage( - 7, - f, - proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter - ); - } - f = message.getRuntimeVersion(); - if (f.length > 0) { - writer.writeString( - 8, - f - ); - } - f = message.getEnabledFeaturesList(); - if (f.length > 0) { - writer.writeRepeatedString( - 9, - f - ); - } - f = message.getActorRuntime(); - if (f != null) { - writer.writeMessage( - 10, - f, - proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter - ); - } }; /** - * optional string id = 1; - * @return {string} + * @enum {number} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.UnlockResponse.Status = { + SUCCESS: 0, + LOCK_DOES_NOT_EXIST: 1, + LOCK_BELONGS_TO_OTHERS: 2, + INTERNAL_ERROR: 3 }; - /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * optional Status status = 1; + * @return {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.UnlockResponse.prototype.getStatus = function() { + return /** @type {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; /** - * repeated ActiveActorsCount active_actors_count = 2; - * @return {!Array} + * @param {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} value + * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getActiveActorsCountList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ActiveActorsCount, 2)); +proto.dapr.proto.runtime.v1.UnlockResponse.prototype.setStatus = function(value) { + return jspb.Message.setProto3EnumField(this, 1, value); }; -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setActiveActorsCountList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); -}; - -/** - * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} - */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addActiveActorsCount = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ActiveActorsCount, opt_index); -}; +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearActiveActorsCountList = function() { - return this.setActiveActorsCountList([]); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.toObject(opt_includeInstance, this); }; /** - * repeated RegisteredComponents registered_components = 3; - * @return {!Array} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getRegisteredComponentsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.RegisteredComponents, 3)); -}; - +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.toObject = function(includeInstance, msg) { + var f, obj = { + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + format: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setRegisteredComponentsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 3, value); + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addRegisteredComponents = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.RegisteredComponents, opt_index); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubtleGetKeyRequest; + return proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader(msg, reader); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearRegisteredComponentsList = function() { - return this.setRegisteredComponentsList([]); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setComponentName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 3: + var value = /** @type {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} */ (reader.readEnum()); + msg.setFormat(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * map extended_metadata = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getExtendedMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearExtendedMetadataMap = function() { - this.getExtendedMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getComponentName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getFormat(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } }; /** - * repeated PubsubSubscription subscriptions = 5; - * @return {!Array} + * @enum {number} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getSubscriptionsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscription, 5)); -}; - - -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setSubscriptionsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 5, value); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat = { + PEM: 0, + JSON: 1 }; - /** - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} + * optional string component_name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addSubscriptions = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 5, opt_value, proto.dapr.proto.runtime.v1.PubsubSubscription, opt_index); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearSubscriptionsList = function() { - return this.setSubscriptionsList([]); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * repeated MetadataHTTPEndpoint http_endpoints = 6; - * @return {!Array} + * optional string name = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getHttpEndpointsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint, 6)); -}; - - -/** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setHttpEndpointsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 6, value); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addHttpEndpoints = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 6, opt_value, proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint, opt_index); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * optional KeyFormat format = 3; + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearHttpEndpointsList = function() { - return this.setHttpEndpointsList([]); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getFormat = function() { + return /** @type {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); }; /** - * optional AppConnectionProperties app_connection_properties = 7; - * @return {?proto.dapr.proto.runtime.v1.AppConnectionProperties} + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} value + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getAppConnectionProperties = function() { - return /** @type{?proto.dapr.proto.runtime.v1.AppConnectionProperties} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.AppConnectionProperties, 7)); +proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setFormat = function(value) { + return jspb.Message.setProto3EnumField(this, 3, value); }; -/** - * @param {?proto.dapr.proto.runtime.v1.AppConnectionProperties|undefined} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setAppConnectionProperties = function(value) { - return jspb.Message.setWrapperField(this, 7, value); -}; - -/** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this - */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearAppConnectionProperties = function() { - return this.setAppConnectionProperties(undefined); -}; +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Returns whether this field is set. - * @return {boolean} + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.hasAppConnectionProperties = function() { - return jspb.Message.getField(this, 7) != null; +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.toObject(opt_includeInstance, this); }; /** - * optional string runtime_version = 8; - * @return {string} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getRuntimeVersion = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 8, "")); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + publicKey: jspb.Message.getFieldWithDefault(msg, 2, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setRuntimeVersion = function(value) { - return jspb.Message.setProto3StringField(this, 8, value); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubtleGetKeyResponse; + return proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinaryFromReader(msg, reader); }; /** - * repeated string enabled_features = 9; - * @return {!Array} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getEnabledFeaturesList = function() { - return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 9)); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setPublicKey(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setEnabledFeaturesList = function(value) { - return jspb.Message.setField(this, 9, value || []); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * @param {string} value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.addEnabledFeatures = function(value, opt_index) { - return jspb.Message.addToRepeatedField(this, 9, value, opt_index); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getPublicKey(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearEnabledFeaturesList = function() { - return this.setEnabledFeaturesList([]); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional ActorRuntime actor_runtime = 10; - * @return {?proto.dapr.proto.runtime.v1.ActorRuntime} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.getActorRuntime = function() { - return /** @type{?proto.dapr.proto.runtime.v1.ActorRuntime} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ActorRuntime, 10)); -}; - - -/** - * @param {?proto.dapr.proto.runtime.v1.ActorRuntime|undefined} value - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.setActorRuntime = function(value) { - return jspb.Message.setWrapperField(this, 10, value); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.GetMetadataResponse} returns this + * optional string public_key = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.clearActorRuntime = function() { - return this.setActorRuntime(undefined); +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.getPublicKey = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} returns this */ -proto.dapr.proto.runtime.v1.GetMetadataResponse.prototype.hasActorRuntime = function() { - return jspb.Message.getField(this, 10) != null; +proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.setPublicKey = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.ActorRuntime.repeatedFields_ = [2]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -11608,8 +16436,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ActorRuntime.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleEncryptRequest.toObject(opt_includeInstance, this); }; @@ -11618,17 +16446,18 @@ proto.dapr.proto.runtime.v1.ActorRuntime.prototype.toObject = function(opt_inclu * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ActorRuntime.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.toObject = function(includeInstance, msg) { var f, obj = { - runtimeStatus: jspb.Message.getFieldWithDefault(msg, 1, 0), - activeActorsList: jspb.Message.toObjectList(msg.getActiveActorsList(), - proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject, includeInstance), - hostReady: jspb.Message.getBooleanFieldWithDefault(msg, 3, false), - placement: jspb.Message.getFieldWithDefault(msg, 4, "") + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + plaintext: msg.getPlaintext_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), + nonce: msg.getNonce_asB64(), + associatedData: msg.getAssociatedData_asB64() }; if (includeInstance) { @@ -11642,23 +16471,23 @@ proto.dapr.proto.runtime.v1.ActorRuntime.toObject = function(includeInstance, ms /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} */ -proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ActorRuntime; - return proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleEncryptRequest; + return proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} */ -proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -11666,21 +16495,28 @@ proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader = function( var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} */ (reader.readEnum()); - msg.setRuntimeStatus(value); + var value = /** @type {string} */ (reader.readString()); + msg.setComponentName(value); break; case 2: - var value = new proto.dapr.proto.runtime.v1.ActiveActorsCount; - reader.readMessage(value,proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader); - msg.addActiveActors(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setPlaintext(value); break; case 3: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setHostReady(value); + var value = /** @type {string} */ (reader.readString()); + msg.setAlgorithm(value); break; case 4: var value = /** @type {string} */ (reader.readString()); - msg.setPlacement(value); + msg.setKeyName(value); + break; + case 5: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setNonce(value); + break; + case 6: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setAssociatedData(value); break; default: reader.skipField(); @@ -11695,9 +16531,9 @@ proto.dapr.proto.runtime.v1.ActorRuntime.deserializeBinaryFromReader = function( * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleEncryptRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -11705,142 +16541,234 @@ proto.dapr.proto.runtime.v1.ActorRuntime.prototype.serializeBinary = function() /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ActorRuntime} message + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ActorRuntime.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getRuntimeStatus(); - if (f !== 0.0) { - writer.writeEnum( + f = message.getComponentName(); + if (f.length > 0) { + writer.writeString( 1, f ); } - f = message.getActiveActorsList(); + f = message.getPlaintext_asU8(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeBytes( 2, - f, - proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter + f ); } - f = message.getHostReady(); - if (f) { - writer.writeBool( + f = message.getAlgorithm(); + if (f.length > 0) { + writer.writeString( 3, f ); } - f = message.getPlacement(); + f = message.getKeyName(); if (f.length > 0) { writer.writeString( 4, f ); } + f = message.getNonce_asU8(); + if (f.length > 0) { + writer.writeBytes( + 5, + f + ); + } + f = message.getAssociatedData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 6, + f + ); + } }; /** - * @enum {number} + * optional string component_name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus = { - INITIALIZING: 0, - DISABLED: 1, - RUNNING: 2 +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; + /** - * optional ActorRuntimeStatus runtime_status = 1; - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getRuntimeStatus = function() { - return /** @type {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * @param {!proto.dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus} value - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + * optional bytes plaintext = 2; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setRuntimeStatus = function(value) { - return jspb.Message.setProto3EnumField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * repeated ActiveActorsCount active_actors = 2; - * @return {!Array} + * optional bytes plaintext = 2; + * This is a type-conversion wrapper around `getPlaintext()` + * @return {string} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getActiveActorsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ActiveActorsCount, 2)); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getPlaintext())); +}; + + +/** + * optional bytes plaintext = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getPlaintext()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getPlaintext())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setPlaintext = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string key_name = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional bytes nonce = 5; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this -*/ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setActiveActorsList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 2, value); + * optional bytes nonce = 5; + * This is a type-conversion wrapper around `getNonce()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getNonce())); }; /** - * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} + * optional bytes nonce = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getNonce()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.addActiveActors = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ActiveActorsCount, opt_index); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getNonce())); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.clearActiveActorsList = function() { - return this.setActiveActorsList([]); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setNonce = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); }; /** - * optional bool host_ready = 3; - * @return {boolean} + * optional bytes associated_data = 6; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getHostReady = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 3, false)); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); }; /** - * @param {boolean} value - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + * optional bytes associated_data = 6; + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {string} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setHostReady = function(value) { - return jspb.Message.setProto3BooleanField(this, 3, value); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getAssociatedData())); }; /** - * optional string placement = 4; - * @return {string} + * optional bytes associated_data = 6; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.getPlacement = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getAssociatedData())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ActorRuntime} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this */ -proto.dapr.proto.runtime.v1.ActorRuntime.prototype.setPlacement = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setAssociatedData = function(value) { + return jspb.Message.setProto3BytesField(this, 6, value); }; @@ -11860,8 +16788,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleEncryptResponse.toObject(opt_includeInstance, this); }; @@ -11870,14 +16798,14 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.toObject = function(opt_ * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.toObject = function(includeInstance, msg) { var f, obj = { - type: jspb.Message.getFieldWithDefault(msg, 1, ""), - count: jspb.Message.getFieldWithDefault(msg, 2, 0) + ciphertext: msg.getCiphertext_asB64(), + tag: msg.getTag_asB64() }; if (includeInstance) { @@ -11891,23 +16819,23 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.toObject = function(includeInstanc /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ActiveActorsCount; - return proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleEncryptResponse; + return proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -11915,12 +16843,12 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader = func var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setType(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setCiphertext(value); break; case 2: - var value = /** @type {number} */ (reader.readInt32()); - msg.setCount(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTag(value); break; default: reader.skipField(); @@ -11935,9 +16863,9 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.deserializeBinaryFromReader = func * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleEncryptResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -11945,22 +16873,22 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.serializeBinary = functi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ActiveActorsCount} message + * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getType(); + f = message.getCiphertext_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 1, f ); } - f = message.getCount(); - if (f !== 0) { - writer.writeInt32( + f = message.getTag_asU8(); + if (f.length > 0) { + writer.writeBytes( 2, f ); @@ -11969,48 +16897,89 @@ proto.dapr.proto.runtime.v1.ActiveActorsCount.serializeBinaryToWriter = function /** - * optional string type = 1; + * optional bytes ciphertext = 1; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes ciphertext = 1; + * This is a type-conversion wrapper around `getCiphertext()` * @return {string} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.getType = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getCiphertext())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} returns this + * optional bytes ciphertext = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getCiphertext()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.setType = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getCiphertext())); }; /** - * optional int32 count = 2; - * @return {number} + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} returns this */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.getCount = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.setCiphertext = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.ActiveActorsCount} returns this + * optional bytes tag = 2; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.ActiveActorsCount.prototype.setCount = function(value) { - return jspb.Message.setProto3IntField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; +/** + * optional bytes tag = 2; + * This is a type-conversion wrapper around `getTag()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTag())); +}; + /** - * List of repeated fields within this message type. - * @private {!Array} - * @const + * optional bytes tag = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTag()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.repeatedFields_ = [4]; +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTag())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} returns this + */ +proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.setTag = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + @@ -12027,8 +16996,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.RegisteredComponents.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleDecryptRequest.toObject(opt_includeInstance, this); }; @@ -12037,16 +17006,19 @@ proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisteredComponents.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.toObject = function(includeInstance, msg) { var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, ""), - type: jspb.Message.getFieldWithDefault(msg, 2, ""), - version: jspb.Message.getFieldWithDefault(msg, 3, ""), - capabilitiesList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? undefined : f + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + ciphertext: msg.getCiphertext_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), + nonce: msg.getNonce_asB64(), + tag: msg.getTag_asB64(), + associatedData: msg.getAssociatedData_asB64() }; if (includeInstance) { @@ -12060,23 +17032,23 @@ proto.dapr.proto.runtime.v1.RegisteredComponents.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.RegisteredComponents; - return proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleDecryptRequest; + return proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -12085,19 +17057,31 @@ proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + msg.setComponentName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setType(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setCiphertext(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setVersion(value); + msg.setAlgorithm(value); break; case 4: var value = /** @type {string} */ (reader.readString()); - msg.addCapabilities(value); + msg.setKeyName(value); + break; + case 5: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setNonce(value); + break; + case 6: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTag(value); + break; + case 7: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setAssociatedData(value); break; default: reader.skipField(); @@ -12112,9 +17096,9 @@ proto.dapr.proto.runtime.v1.RegisteredComponents.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleDecryptRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -12122,131 +17106,283 @@ proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.RegisteredComponents} message + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RegisteredComponents.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getName(); + f = message.getComponentName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getType(); + f = message.getCiphertext_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 2, f ); } - f = message.getVersion(); + f = message.getAlgorithm(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getCapabilitiesList(); + f = message.getKeyName(); if (f.length > 0) { - writer.writeRepeatedString( + writer.writeString( 4, f ); } + f = message.getNonce_asU8(); + if (f.length > 0) { + writer.writeBytes( + 5, + f + ); + } + f = message.getTag_asU8(); + if (f.length > 0) { + writer.writeBytes( + 6, + f + ); + } + f = message.getAssociatedData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 7, + f + ); + } }; /** - * optional string name = 1; + * optional string component_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getName = function() { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getComponentName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setName = function(value) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setComponentName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string type = 2; + * optional bytes ciphertext = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes ciphertext = 2; + * This is a type-conversion wrapper around `getCiphertext()` * @return {string} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getType = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getCiphertext())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * optional bytes ciphertext = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getCiphertext()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setType = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getCiphertext())); }; /** - * optional string version = 3; + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setCiphertext = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getVersion = function() { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAlgorithm = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setVersion = function(value) { +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setAlgorithm = function(value) { return jspb.Message.setProto3StringField(this, 3, value); }; /** - * repeated string capabilities = 4; - * @return {!Array} + * optional string key_name = 4; + * @return {string} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.getCapabilitiesList = function() { - return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 4)); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.setCapabilitiesList = function(value) { - return jspb.Message.setField(this, 4, value || []); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; /** - * @param {string} value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * optional bytes nonce = 5; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.addCapabilities = function(value, opt_index) { - return jspb.Message.addToRepeatedField(this, 4, value, opt_index); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.RegisteredComponents} returns this + * optional bytes nonce = 5; + * This is a type-conversion wrapper around `getNonce()` + * @return {string} */ -proto.dapr.proto.runtime.v1.RegisteredComponents.prototype.clearCapabilitiesList = function() { - return this.setCapabilitiesList([]); +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getNonce())); +}; + + +/** + * optional bytes nonce = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getNonce()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getNonce())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setNonce = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); +}; + + +/** + * optional bytes tag = 6; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +}; + + +/** + * optional bytes tag = 6; + * This is a type-conversion wrapper around `getTag()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTag())); +}; + + +/** + * optional bytes tag = 6; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTag()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTag())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setTag = function(value) { + return jspb.Message.setProto3BytesField(this, 6, value); +}; + + +/** + * optional bytes associated_data = 7; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +}; + + +/** + * optional bytes associated_data = 7; + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getAssociatedData())); +}; + + +/** + * optional bytes associated_data = 7; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getAssociatedData())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setAssociatedData = function(value) { + return jspb.Message.setProto3BytesField(this, 7, value); }; @@ -12266,8 +17402,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleDecryptResponse.toObject(opt_includeInstance, this); }; @@ -12276,13 +17412,13 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.toObject = function(includeInstance, msg) { var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, "") + plaintext: msg.getPlaintext_asB64() }; if (includeInstance) { @@ -12296,23 +17432,23 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint; - return proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubtleDecryptResponse; + return proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -12320,8 +17456,8 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader = f var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setPlaintext(value); break; default: reader.skipField(); @@ -12336,9 +17472,9 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleDecryptResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -12346,15 +17482,15 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} message + * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getName(); + f = message.getPlaintext_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 1, f ); @@ -12363,20 +17499,44 @@ proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.serializeBinaryToWriter = funct /** - * optional string name = 1; + * optional bytes plaintext = 1; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes plaintext = 1; + * This is a type-conversion wrapper around `getPlaintext()` * @return {string} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getPlaintext())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint} returns this + * optional bytes plaintext = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getPlaintext()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.MetadataHTTPEndpoint.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getPlaintext())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} returns this + */ +proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.setPlaintext = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; @@ -12396,8 +17556,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.toObject(opt_includeInstance, this); }; @@ -12406,17 +17566,18 @@ proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.toObject = functio * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.toObject = function(includeInstance, msg) { var f, obj = { - port: jspb.Message.getFieldWithDefault(msg, 1, 0), - protocol: jspb.Message.getFieldWithDefault(msg, 2, ""), - channelAddress: jspb.Message.getFieldWithDefault(msg, 3, ""), - maxConcurrency: jspb.Message.getFieldWithDefault(msg, 4, 0), - health: (f = msg.getHealth()) && proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject(includeInstance, f) + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + plaintextKey: msg.getPlaintextKey_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), + nonce: msg.getNonce_asB64(), + associatedData: msg.getAssociatedData_asB64() }; if (includeInstance) { @@ -12430,23 +17591,23 @@ proto.dapr.proto.runtime.v1.AppConnectionProperties.toObject = function(includeI /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.AppConnectionProperties; - return proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest; + return proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -12454,25 +17615,28 @@ proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {number} */ (reader.readInt32()); - msg.setPort(value); + var value = /** @type {string} */ (reader.readString()); + msg.setComponentName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setProtocol(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setPlaintextKey(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setChannelAddress(value); + msg.setAlgorithm(value); break; case 4: - var value = /** @type {number} */ (reader.readInt32()); - msg.setMaxConcurrency(value); + var value = /** @type {string} */ (reader.readString()); + msg.setKeyName(value); break; case 5: - var value = new proto.dapr.proto.runtime.v1.AppConnectionHealthProperties; - reader.readMessage(value,proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader); - msg.setHealth(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setNonce(value); + break; + case 6: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setAssociatedData(value); break; default: reader.skipField(); @@ -12487,9 +17651,9 @@ proto.dapr.proto.runtime.v1.AppConnectionProperties.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -12497,157 +17661,234 @@ proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.AppConnectionProperties} message + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPort(); - if (f !== 0) { - writer.writeInt32( + f = message.getComponentName(); + if (f.length > 0) { + writer.writeString( 1, f ); } - f = message.getProtocol(); + f = message.getPlaintextKey_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 2, f ); } - f = message.getChannelAddress(); + f = message.getAlgorithm(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getMaxConcurrency(); - if (f !== 0) { - writer.writeInt32( + f = message.getKeyName(); + if (f.length > 0) { + writer.writeString( 4, f ); } - f = message.getHealth(); - if (f != null) { - writer.writeMessage( + f = message.getNonce_asU8(); + if (f.length > 0) { + writer.writeBytes( 5, - f, - proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter + f + ); + } + f = message.getAssociatedData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 6, + f ); } }; /** - * optional int32 port = 1; - * @return {number} + * optional string component_name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getPort = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setPort = function(value) { - return jspb.Message.setProto3IntField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string protocol = 2; + * optional bytes plaintext_key = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes plaintext_key = 2; + * This is a type-conversion wrapper around `getPlaintextKey()` * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getProtocol = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getPlaintextKey())); +}; + + +/** + * optional bytes plaintext_key = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getPlaintextKey()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getPlaintextKey())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setPlaintextKey = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setProtocol = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string key_name = 4; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional bytes nonce = 5; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * optional string channel_address = 3; + * optional bytes nonce = 5; + * This is a type-conversion wrapper around `getNonce()` * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getChannelAddress = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getNonce())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + * optional bytes nonce = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getNonce()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setChannelAddress = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getNonce())); }; /** - * optional int32 max_concurrency = 4; - * @return {number} + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getMaxConcurrency = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setNonce = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + * optional bytes associated_data = 6; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setMaxConcurrency = function(value) { - return jspb.Message.setProto3IntField(this, 4, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); }; /** - * optional AppConnectionHealthProperties health = 5; - * @return {?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} + * optional bytes associated_data = 6; + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.getHealth = function() { - return /** @type{?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.AppConnectionHealthProperties, 5)); -}; - - -/** - * @param {?proto.dapr.proto.runtime.v1.AppConnectionHealthProperties|undefined} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this -*/ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.setHealth = function(value) { - return jspb.Message.setWrapperField(this, 5, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getAssociatedData())); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.AppConnectionProperties} returns this + * optional bytes associated_data = 6; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.clearHealth = function() { - return this.setHealth(undefined); +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getAssociatedData())); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionProperties.prototype.hasHealth = function() { - return jspb.Message.getField(this, 5) != null; +proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setAssociatedData = function(value) { + return jspb.Message.setProto3BytesField(this, 6, value); }; @@ -12667,8 +17908,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.toObject(opt_includeInstance, this); }; @@ -12677,16 +17918,14 @@ proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.toObject = f * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.toObject = function(includeInstance, msg) { var f, obj = { - healthCheckPath: jspb.Message.getFieldWithDefault(msg, 1, ""), - healthProbeInterval: jspb.Message.getFieldWithDefault(msg, 2, ""), - healthProbeTimeout: jspb.Message.getFieldWithDefault(msg, 3, ""), - healthThreshold: jspb.Message.getFieldWithDefault(msg, 4, 0) + wrappedKey: msg.getWrappedKey_asB64(), + tag: msg.getTag_asB64() }; if (includeInstance) { @@ -12700,23 +17939,23 @@ proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.toObject = function(in /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.AppConnectionHealthProperties; - return proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse; + return proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -12724,20 +17963,12 @@ proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromR var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setHealthCheckPath(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setWrappedKey(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setHealthProbeInterval(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setHealthProbeTimeout(value); - break; - case 4: - var value = /** @type {number} */ (reader.readInt32()); - msg.setHealthThreshold(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTag(value); break; default: reader.skipField(); @@ -12752,9 +17983,9 @@ proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.deserializeBinaryFromR * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -12762,112 +17993,110 @@ proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.serializeBin /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} message + * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getHealthCheckPath(); + f = message.getWrappedKey_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 1, f ); } - f = message.getHealthProbeInterval(); + f = message.getTag_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 2, f ); } - f = message.getHealthProbeTimeout(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getHealthThreshold(); - if (f !== 0) { - writer.writeInt32( - 4, - f - ); - } }; /** - * optional string health_check_path = 1; - * @return {string} + * optional bytes wrapped_key = 1; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthCheckPath = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this + * optional bytes wrapped_key = 1; + * This is a type-conversion wrapper around `getWrappedKey()` + * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthCheckPath = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getWrappedKey())); }; /** - * optional string health_probe_interval = 2; - * @return {string} + * optional bytes wrapped_key = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getWrappedKey()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthProbeInterval = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getWrappedKey())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthProbeInterval = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.setWrappedKey = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; /** - * optional string health_probe_timeout = 3; - * @return {string} + * optional bytes tag = 2; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthProbeTimeout = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this + * optional bytes tag = 2; + * This is a type-conversion wrapper around `getTag()` + * @return {string} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthProbeTimeout = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTag())); }; /** - * optional int32 health_threshold = 4; - * @return {number} + * optional bytes tag = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTag()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.getHealthThreshold = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTag())); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.AppConnectionHealthProperties} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} returns this */ -proto.dapr.proto.runtime.v1.AppConnectionHealthProperties.prototype.setHealthThreshold = function(value) { - return jspb.Message.setProto3IntField(this, 4, value); +proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.setTag = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); }; @@ -12887,8 +18116,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PubsubSubscription.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.toObject(opt_includeInstance, this); }; @@ -12897,18 +18126,19 @@ proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscription.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.toObject = function(includeInstance, msg) { var f, obj = { - pubsubName: jspb.Message.getFieldWithDefault(msg, 1, ""), - topic: jspb.Message.getFieldWithDefault(msg, 2, ""), - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], - rules: (f = msg.getRules()) && proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject(includeInstance, f), - deadLetterTopic: jspb.Message.getFieldWithDefault(msg, 5, ""), - type: jspb.Message.getFieldWithDefault(msg, 6, 0) + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + wrappedKey: msg.getWrappedKey_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), + nonce: msg.getNonce_asB64(), + tag: msg.getTag_asB64(), + associatedData: msg.getAssociatedData_asB64() }; if (includeInstance) { @@ -12922,23 +18152,23 @@ proto.dapr.proto.runtime.v1.PubsubSubscription.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PubsubSubscription; - return proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest; + return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -12947,30 +18177,31 @@ proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader = fun switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setPubsubName(value); + msg.setComponentName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setTopic(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setWrappedKey(value); break; case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setAlgorithm(value); break; case 4: - var value = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRules; - reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader); - msg.setRules(value); + var value = /** @type {string} */ (reader.readString()); + msg.setKeyName(value); break; case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setDeadLetterTopic(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setNonce(value); break; case 6: - var value = /** @type {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} */ (reader.readEnum()); - msg.setType(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTag(value); + break; + case 7: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setAssociatedData(value); break; default: reader.skipField(); @@ -12985,9 +18216,9 @@ proto.dapr.proto.runtime.v1.PubsubSubscription.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -12995,195 +18226,287 @@ proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscription} message + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscription.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPubsubName(); + f = message.getComponentName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getTopic(); + f = message.getWrappedKey_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 2, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getAlgorithm(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); } - f = message.getRules(); - if (f != null) { - writer.writeMessage( + f = message.getKeyName(); + if (f.length > 0) { + writer.writeString( 4, - f, - proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter + f ); } - f = message.getDeadLetterTopic(); + f = message.getNonce_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 5, f ); } - f = message.getType(); - if (f !== 0.0) { - writer.writeEnum( + f = message.getTag_asU8(); + if (f.length > 0) { + writer.writeBytes( 6, f ); } + f = message.getAssociatedData_asU8(); + if (f.length > 0) { + writer.writeBytes( + 7, + f + ); + } }; /** - * optional string pubsub_name = 1; + * optional string component_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getPubsubName = function() { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getComponentName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setPubsubName = function(value) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setComponentName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string topic = 2; + * optional bytes wrapped_key = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes wrapped_key = 2; + * This is a type-conversion wrapper around `getWrappedKey()` * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getTopic = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getWrappedKey())); +}; + + +/** + * optional bytes wrapped_key = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getWrappedKey()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getWrappedKey())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setWrappedKey = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setTopic = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string key_name = 4; + * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; /** - * optional PubsubSubscriptionRules rules = 4; - * @return {?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} + * optional bytes nonce = 5; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getRules = function() { - return /** @type{?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscriptionRules, 4)); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * @param {?proto.dapr.proto.runtime.v1.PubsubSubscriptionRules|undefined} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this -*/ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setRules = function(value) { - return jspb.Message.setWrapperField(this, 4, value); + * optional bytes nonce = 5; + * This is a type-conversion wrapper around `getNonce()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getNonce())); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * optional bytes nonce = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getNonce()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.clearRules = function() { - return this.setRules(undefined); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getNonce())); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.hasRules = function() { - return jspb.Message.getField(this, 4) != null; +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setNonce = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); }; /** - * optional string dead_letter_topic = 5; + * optional bytes tag = 6; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +}; + + +/** + * optional bytes tag = 6; + * This is a type-conversion wrapper around `getTag()` * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getDeadLetterTopic = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTag())); +}; + + +/** + * optional bytes tag = 6; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTag()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTag())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setTag = function(value) { + return jspb.Message.setProto3BytesField(this, 6, value); +}; + + +/** + * optional bytes associated_data = 7; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * optional bytes associated_data = 7; + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setDeadLetterTopic = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getAssociatedData())); }; /** - * optional PubsubSubscriptionType type = 6; - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} + * optional bytes associated_data = 7; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getAssociatedData()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.getType = function() { - return /** @type {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getAssociatedData())); }; /** - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionType} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscription} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscription.prototype.setType = function(value) { - return jspb.Message.setProto3EnumField(this, 6, value); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setAssociatedData = function(value) { + return jspb.Message.setProto3BytesField(this, 7, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.repeatedFields_ = [1]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -13199,8 +18522,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.toObject(opt_includeInstance, this); }; @@ -13209,14 +18532,13 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.toObject = functio * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.toObject = function(includeInstance, msg) { var f, obj = { - rulesList: jspb.Message.toObjectList(msg.getRulesList(), - proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject, includeInstance) + plaintextKey: msg.getPlaintextKey_asB64() }; if (includeInstance) { @@ -13230,23 +18552,23 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.toObject = function(includeI /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRules; - return proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse; + return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -13254,9 +18576,8 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRule; - reader.readMessage(value,proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader); - msg.addRules(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setPlaintextKey(value); break; default: reader.skipField(); @@ -13271,9 +18592,9 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -13281,58 +18602,61 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} message + * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getRulesList(); + f = message.getPlaintextKey_asU8(); if (f.length > 0) { - writer.writeRepeatedMessage( + writer.writeBytes( 1, - f, - proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter + f ); } }; /** - * repeated PubsubSubscriptionRule rules = 1; - * @return {!Array} + * optional bytes plaintext_key = 1; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.getRulesList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.PubsubSubscriptionRule, 1)); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} returns this -*/ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.setRulesList = function(value) { - return jspb.Message.setRepeatedWrapperField(this, 1, value); + * optional bytes plaintext_key = 1; + * This is a type-conversion wrapper around `getPlaintextKey()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getPlaintextKey())); }; /** - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule=} opt_value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} + * optional bytes plaintext_key = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getPlaintextKey()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.addRules = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.PubsubSubscriptionRule, opt_index); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getPlaintextKey())); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRules} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRules.prototype.clearRulesList = function() { - return this.setRulesList([]); +proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.setPlaintextKey = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; @@ -13352,8 +18676,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleSignRequest.toObject(opt_includeInstance, this); }; @@ -13362,14 +18686,16 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.toObject = function * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleSignRequest.toObject = function(includeInstance, msg) { var f, obj = { - match: jspb.Message.getFieldWithDefault(msg, 1, ""), - path: jspb.Message.getFieldWithDefault(msg, 2, "") + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + digest: msg.getDigest_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, "") }; if (includeInstance) { @@ -13383,23 +18709,23 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.toObject = function(includeIn /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PubsubSubscriptionRule; - return proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleSignRequest; + return proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -13408,11 +18734,19 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader = switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setMatch(value); + msg.setComponentName(value); break; case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setDigest(value); + break; + case 3: var value = /** @type {string} */ (reader.readString()); - msg.setPath(value); + msg.setAlgorithm(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setKeyName(value); break; default: reader.skipField(); @@ -13427,9 +18761,9 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleSignRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -13437,62 +18771,136 @@ proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.serializeBinary = f /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} message + * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleSignRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getMatch(); + f = message.getComponentName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getPath(); + f = message.getDigest_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 2, f ); } + f = message.getAlgorithm(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getKeyName(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } }; /** - * optional string match = 1; + * optional string component_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes digest = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes digest = 2; + * This is a type-conversion wrapper around `getDigest()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getDigest())); +}; + + +/** + * optional bytes digest = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getDigest()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getDigest())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setDigest = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.getMatch = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.setMatch = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional string path = 2; + * optional string key_name = 4; * @return {string} */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.getPath = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PubsubSubscriptionRule} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this */ -proto.dapr.proto.runtime.v1.PubsubSubscriptionRule.prototype.setPath = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; @@ -13512,8 +18920,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SetMetadataRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleSignResponse.toObject(opt_includeInstance, this); }; @@ -13522,14 +18930,13 @@ proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleSignResponse.toObject = function(includeInstance, msg) { var f, obj = { - key: jspb.Message.getFieldWithDefault(msg, 1, ""), - value: jspb.Message.getFieldWithDefault(msg, 2, "") + signature: msg.getSignature_asB64() }; if (includeInstance) { @@ -13543,23 +18950,23 @@ proto.dapr.proto.runtime.v1.SetMetadataRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} + * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SetMetadataRequest; - return proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleSignResponse; + return proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} + * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -13567,12 +18974,8 @@ proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader = fun var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setKey(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setValue(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setSignature(value); break; default: reader.skipField(); @@ -13587,9 +18990,9 @@ proto.dapr.proto.runtime.v1.SetMetadataRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SetMetadataRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleSignResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -13597,73 +19000,65 @@ proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SetMetadataRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleSignResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getKey(); + f = message.getSignature_asU8(); if (f.length > 0) { - writer.writeString( + writer.writeBytes( 1, f ); } - f = message.getValue(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } }; /** - * optional string key = 1; - * @return {string} + * optional bytes signature = 1; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.getKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} returns this + * optional bytes signature = 1; + * This is a type-conversion wrapper around `getSignature()` + * @return {string} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.setKey = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getSignature())); }; /** - * optional string value = 2; - * @return {string} + * optional bytes signature = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getSignature()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.getValue = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getSignature())); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SetMetadataRequest} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} returns this */ -proto.dapr.proto.runtime.v1.SetMetadataRequest.prototype.setValue = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.setSignature = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.repeatedFields_ = [2]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -13679,8 +19074,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetConfigurationRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleVerifyRequest.toObject(opt_includeInstance, this); }; @@ -13689,15 +19084,17 @@ proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.toObject = functio * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + digest: msg.getDigest_asB64(), + algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), + signature: msg.getSignature_asB64() }; if (includeInstance) { @@ -13711,23 +19108,23 @@ proto.dapr.proto.runtime.v1.GetConfigurationRequest.toObject = function(includeI /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetConfigurationRequest; - return proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleVerifyRequest; + return proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -13736,17 +19133,23 @@ proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setComponentName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.addKeys(value); + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setDigest(value); break; case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = /** @type {string} */ (reader.readString()); + msg.setAlgorithm(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setKeyName(value); + break; + case 5: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setSignature(value); break; default: reader.skipField(); @@ -13761,9 +19164,9 @@ proto.dapr.proto.runtime.v1.GetConfigurationRequest.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetConfigurationRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleVerifyRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -13771,108 +19174,185 @@ proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} message + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getComponentName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getKeysList(); + f = message.getDigest_asU8(); if (f.length > 0) { - writer.writeRepeatedString( + writer.writeBytes( 2, f ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + f = message.getAlgorithm(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); } + f = message.getKeyName(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getSignature_asU8(); + if (f.length > 0) { + writer.writeBytes( + 5, + f + ); + } +}; + + +/** + * optional string component_name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional bytes digest = 2; + * @return {!(string|Uint8Array)} + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes digest = 2; + * This is a type-conversion wrapper around `getDigest()` + * @return {string} + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getDigest())); +}; + + +/** + * optional bytes digest = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getDigest()` + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getDigest())); }; /** - * optional string store_name = 1; + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this + */ +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setDigest = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional string algorithm = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * repeated string keys = 2; - * @return {!Array} + * optional string key_name = 4; + * @return {string} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getKeysList = function() { - return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.setKeysList = function(value) { - return jspb.Message.setField(this, 2, value || []); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); }; /** - * @param {string} value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this + * optional bytes signature = 5; + * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.addKeys = function(value, opt_index) { - return jspb.Message.addToRepeatedField(this, 2, value, opt_index); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this + * optional bytes signature = 5; + * This is a type-conversion wrapper around `getSignature()` + * @return {string} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.clearKeysList = function() { - return this.setKeysList([]); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getSignature())); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional bytes signature = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getSignature()` + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getSignature())); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationRequest} returns this + * @param {!(string|Uint8Array)} value + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this */ -proto.dapr.proto.runtime.v1.GetConfigurationRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setSignature = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); }; @@ -13892,8 +19372,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetConfigurationResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.SubtleVerifyResponse.toObject(opt_includeInstance, this); }; @@ -13902,13 +19382,13 @@ proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.toObject = functi * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.toObject = function(includeInstance, msg) { var f, obj = { - itemsMap: (f = msg.getItemsMap()) ? f.toObject(includeInstance, proto.dapr.proto.common.v1.ConfigurationItem.toObject) : [] + valid: jspb.Message.getBooleanFieldWithDefault(msg, 1, false) }; if (includeInstance) { @@ -13922,23 +19402,23 @@ proto.dapr.proto.runtime.v1.GetConfigurationResponse.toObject = function(include /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetConfigurationResponse; - return proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.SubtleVerifyResponse; + return proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -13946,10 +19426,8 @@ proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader var field = reader.getFieldNumber(); switch (field) { case 1: - var value = msg.getItemsMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.common.v1.ConfigurationItem.deserializeBinaryFromReader, "", new proto.dapr.proto.common.v1.ConfigurationItem()); - }); + var value = /** @type {boolean} */ (reader.readBool()); + msg.setValid(value); break; default: reader.skipField(); @@ -13964,9 +19442,9 @@ proto.dapr.proto.runtime.v1.GetConfigurationResponse.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetConfigurationResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.SubtleVerifyResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -13974,50 +19452,41 @@ proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} message + * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getItemsMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.common.v1.ConfigurationItem.serializeBinaryToWriter); + f = message.getValid(); + if (f) { + writer.writeBool( + 1, + f + ); } }; /** - * map items = 1; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional bool valid = 1; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.getItemsMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 1, opt_noLazyCreate, - proto.dapr.proto.common.v1.ConfigurationItem)); +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.getValid = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetConfigurationResponse} returns this + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} returns this */ -proto.dapr.proto.runtime.v1.GetConfigurationResponse.prototype.clearItemsMap = function() { - this.getItemsMap().clear(); - return this; +proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.setValid = function(value) { + return jspb.Message.setProto3BooleanField(this, 1, value); }; -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.repeatedFields_ = [2]; - if (jspb.Message.GENERATE_TO_OBJECT) { @@ -14033,8 +19502,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.EncryptRequest.toObject(opt_includeInstance, this); }; @@ -14043,15 +19512,14 @@ proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.toObject = f * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.EncryptRequest.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - keysList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f, - metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [] + options: (f = msg.getOptions()) && proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject(includeInstance, f), + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) }; if (includeInstance) { @@ -14065,23 +19533,23 @@ proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.toObject = function(in /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest; - return proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.EncryptRequest; + return proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -14089,18 +19557,14 @@ proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromR var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + var value = new proto.dapr.proto.runtime.v1.EncryptRequestOptions; + reader.readMessage(value,proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader); + msg.setOptions(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.addKeys(value); - break; - case 3: - var value = msg.getMetadataMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); break; default: reader.skipField(); @@ -14115,9 +19579,9 @@ proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.deserializeBinaryFromR * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.EncryptRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -14125,108 +19589,102 @@ proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.serializeBin /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} message + * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.EncryptRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( + f = message.getOptions(); + if (f != null) { + writer.writeMessage( 1, - f + f, + proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter ); } - f = message.getKeysList(); - if (f.length > 0) { - writer.writeRepeatedString( + f = message.getPayload(); + if (f != null) { + writer.writeMessage( 2, - f + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter ); } - f = message.getMetadataMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(3, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } -}; - - -/** - * optional string store_name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + * optional EncryptRequestOptions options = 1; + * @return {?proto.dapr.proto.runtime.v1.EncryptRequestOptions} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.getOptions = function() { + return /** @type{?proto.dapr.proto.runtime.v1.EncryptRequestOptions} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.EncryptRequestOptions, 1)); }; /** - * repeated string keys = 2; - * @return {!Array} - */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getKeysList = function() { - return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); + * @param {?proto.dapr.proto.runtime.v1.EncryptRequestOptions|undefined} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this +*/ +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.setOptions = function(value) { + return jspb.Message.setWrapperField(this, 1, value); }; /** - * @param {!Array} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.setKeysList = function(value) { - return jspb.Message.setField(this, 2, value || []); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearOptions = function() { + return this.setOptions(undefined); }; /** - * @param {string} value - * @param {number=} opt_index - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.addKeys = function(value, opt_index) { - return jspb.Message.addToRepeatedField(this, 2, value, opt_index); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.hasOptions = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * Clears the list making it empty but non-null. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + * optional dapr.proto.common.v1.StreamPayload payload = 2; + * @return {?proto.dapr.proto.common.v1.StreamPayload} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.clearKeysList = function() { - return this.setKeysList([]); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); }; /** - * map metadata = 3; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this +*/ +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 3, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearPayload = function() { + return this.setPayload(undefined); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationRequest.prototype.clearMetadataMap = function() { - this.getMetadataMap().clear(); - return this; +proto.dapr.proto.runtime.v1.EncryptRequest.prototype.hasPayload = function() { + return jspb.Message.getField(this, 2) != null; }; @@ -14246,8 +19704,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject(opt_includeInstance, this); }; @@ -14256,14 +19714,18 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.toObject = * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - id: jspb.Message.getFieldWithDefault(msg, 2, "") + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 2, ""), + keyWrapAlgorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), + dataEncryptionCipher: jspb.Message.getFieldWithDefault(msg, 10, ""), + omitDecryptionKeyName: jspb.Message.getBooleanFieldWithDefault(msg, 11, false), + decryptionKeyName: jspb.Message.getFieldWithDefault(msg, 12, "") }; if (includeInstance) { @@ -14277,23 +19739,23 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.toObject = function( /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest; - return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.EncryptRequestOptions; + return proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -14302,11 +19764,27 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFro switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + msg.setComponentName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setId(value); + msg.setKeyName(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setKeyWrapAlgorithm(value); + break; + case 10: + var value = /** @type {string} */ (reader.readString()); + msg.setDataEncryptionCipher(value); + break; + case 11: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setOmitDecryptionKeyName(value); + break; + case 12: + var value = /** @type {string} */ (reader.readString()); + msg.setDecryptionKeyName(value); break; default: reader.skipField(); @@ -14321,9 +19799,9 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.deserializeBinaryFro * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -14331,226 +19809,162 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.serializeB /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} message + * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); + f = message.getComponentName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getId(); + f = message.getKeyName(); if (f.length > 0) { writer.writeString( 2, f ); } + f = message.getKeyWrapAlgorithm(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getDataEncryptionCipher(); + if (f.length > 0) { + writer.writeString( + 10, + f + ); + } + f = message.getOmitDecryptionKeyName(); + if (f) { + writer.writeBool( + 11, + f + ); + } + f = message.getDecryptionKeyName(); + if (f.length > 0) { + writer.writeString( + 12, + f + ); + } }; /** - * optional string store_name = 1; + * optional string component_name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.getStoreName = function() { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getComponentName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.setStoreName = function(value) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setComponentName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string id = 2; + * optional string key_name = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.getId = function() { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getKeyName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationRequest.prototype.setId = function(value) { +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setKeyName = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} - */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages - */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.toObject = function(includeInstance, msg) { - var f, obj = { - id: jspb.Message.getFieldWithDefault(msg, 1, ""), - itemsMap: (f = msg.getItemsMap()) ? f.toObject(includeInstance, proto.dapr.proto.common.v1.ConfigurationItem.toObject) : [] - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} + * optional string key_wrap_algorithm = 3; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse; - return proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getKeyWrapAlgorithm = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setId(value); - break; - case 2: - var value = msg.getItemsMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.dapr.proto.common.v1.ConfigurationItem.deserializeBinaryFromReader, "", new proto.dapr.proto.common.v1.ConfigurationItem()); - }); - break; - default: - reader.skipField(); - break; - } - } - return msg; +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setKeyWrapAlgorithm = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * optional string data_encryption_cipher = 10; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getDataEncryptionCipher = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 10, "")); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getId(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getItemsMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.dapr.proto.common.v1.ConfigurationItem.serializeBinaryToWriter); - } +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setDataEncryptionCipher = function(value) { + return jspb.Message.setProto3StringField(this, 10, value); }; /** - * optional string id = 1; - * @return {string} + * optional bool omit_decryption_key_name = 11; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.getId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getOmitDecryptionKeyName = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 11, false)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} returns this + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.setId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setOmitDecryptionKeyName = function(value) { + return jspb.Message.setProto3BooleanField(this, 11, value); }; /** - * map items = 2; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * optional string decryption_key_name = 12; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.getItemsMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 2, opt_noLazyCreate, - proto.dapr.proto.common.v1.ConfigurationItem)); +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getDecryptionKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 12, "")); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.SubscribeConfigurationResponse.prototype.clearItemsMap = function() { - this.getItemsMap().clear(); - return this; +proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setDecryptionKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 12, value); }; @@ -14570,8 +19984,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.EncryptResponse.toObject(opt_includeInstance, this); }; @@ -14580,14 +19994,13 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.toObject * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.EncryptResponse.toObject = function(includeInstance, msg) { var f, obj = { - ok: jspb.Message.getBooleanFieldWithDefault(msg, 1, false), - message: jspb.Message.getFieldWithDefault(msg, 2, "") + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) }; if (includeInstance) { @@ -14601,23 +20014,23 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.toObject = function /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} + * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse; - return proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.EncryptResponse; + return proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} + * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -14625,12 +20038,9 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFr var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setOk(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setMessage(value); + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); break; default: reader.skipField(); @@ -14645,9 +20055,9 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.deserializeBinaryFr * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.EncryptResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -14655,62 +20065,57 @@ proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.serialize /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} message + * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.EncryptResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getOk(); - if (f) { - writer.writeBool( + f = message.getPayload(); + if (f != null) { + writer.writeMessage( 1, - f - ); - } - f = message.getMessage(); - if (f.length > 0) { - writer.writeString( - 2, - f + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter ); } }; /** - * optional bool ok = 1; - * @return {boolean} + * optional dapr.proto.common.v1.StreamPayload payload = 1; + * @return {?proto.dapr.proto.common.v1.StreamPayload} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.getOk = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 1)); }; /** - * @param {boolean} value - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} returns this - */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.setOk = function(value) { - return jspb.Message.setProto3BooleanField(this, 1, value); + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} returns this +*/ +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 1, value); }; /** - * optional string message = 2; - * @return {string} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} returns this */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.clearPayload = function() { + return this.setPayload(undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.UnsubscribeConfigurationResponse.prototype.setMessage = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.EncryptResponse.prototype.hasPayload = function() { + return jspb.Message.getField(this, 1) != null; }; @@ -14730,8 +20135,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.TryLockRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DecryptRequest.toObject(opt_includeInstance, this); }; @@ -14740,16 +20145,14 @@ proto.dapr.proto.runtime.v1.TryLockRequest.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TryLockRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.DecryptRequest.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - resourceId: jspb.Message.getFieldWithDefault(msg, 2, ""), - lockOwner: jspb.Message.getFieldWithDefault(msg, 3, ""), - expiryInSeconds: jspb.Message.getFieldWithDefault(msg, 4, 0) + options: (f = msg.getOptions()) && proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject(includeInstance, f), + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) }; if (includeInstance) { @@ -14763,23 +20166,23 @@ proto.dapr.proto.runtime.v1.TryLockRequest.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} */ -proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.TryLockRequest; - return proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.DecryptRequest; + return proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} */ -proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -14787,20 +20190,14 @@ proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); + var value = new proto.dapr.proto.runtime.v1.DecryptRequestOptions; + reader.readMessage(value,proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader); + msg.setOptions(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setResourceId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setLockOwner(value); - break; - case 4: - var value = /** @type {number} */ (reader.readInt32()); - msg.setExpiryInSeconds(value); + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); break; default: reader.skipField(); @@ -14815,9 +20212,9 @@ proto.dapr.proto.runtime.v1.TryLockRequest.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.TryLockRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.DecryptRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -14825,112 +20222,102 @@ proto.dapr.proto.runtime.v1.TryLockRequest.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.TryLockRequest} message + * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TryLockRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.DecryptRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( + f = message.getOptions(); + if (f != null) { + writer.writeMessage( 1, - f + f, + proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter ); } - f = message.getResourceId(); - if (f.length > 0) { - writer.writeString( + f = message.getPayload(); + if (f != null) { + writer.writeMessage( 2, - f - ); - } - f = message.getLockOwner(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getExpiryInSeconds(); - if (f !== 0) { - writer.writeInt32( - 4, - f + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter ); } }; /** - * optional string store_name = 1; - * @return {string} + * optional DecryptRequestOptions options = 1; + * @return {?proto.dapr.proto.runtime.v1.DecryptRequestOptions} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.getOptions = function() { + return /** @type{?proto.dapr.proto.runtime.v1.DecryptRequestOptions} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.DecryptRequestOptions, 1)); }; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this - */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); + + +/** + * @param {?proto.dapr.proto.runtime.v1.DecryptRequestOptions|undefined} value + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this +*/ +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.setOptions = function(value) { + return jspb.Message.setWrapperField(this, 1, value); }; /** - * optional string resource_id = 2; - * @return {string} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getResourceId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearOptions = function() { + return this.setOptions(undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setResourceId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.hasOptions = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * optional string lock_owner = 3; - * @return {string} + * optional dapr.proto.common.v1.StreamPayload payload = 2; + * @return {?proto.dapr.proto.common.v1.StreamPayload} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getLockOwner = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this - */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setLockOwner = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this +*/ +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 2, value); }; /** - * optional int32 expiry_in_seconds = 4; - * @return {number} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.getExpiryInSeconds = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearPayload = function() { + return this.setPayload(undefined); }; /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.TryLockRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.TryLockRequest.prototype.setExpiryInSeconds = function(value) { - return jspb.Message.setProto3IntField(this, 4, value); +proto.dapr.proto.runtime.v1.DecryptRequest.prototype.hasPayload = function() { + return jspb.Message.getField(this, 2) != null; }; @@ -14950,8 +20337,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.TryLockResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.TryLockResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject(opt_includeInstance, this); }; @@ -14960,13 +20347,14 @@ proto.dapr.proto.runtime.v1.TryLockResponse.prototype.toObject = function(opt_in * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TryLockResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject = function(includeInstance, msg) { var f, obj = { - success: jspb.Message.getBooleanFieldWithDefault(msg, 1, false) + componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), + keyName: jspb.Message.getFieldWithDefault(msg, 12, "") }; if (includeInstance) { @@ -14980,23 +20368,23 @@ proto.dapr.proto.runtime.v1.TryLockResponse.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} + * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} */ -proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.TryLockResponse; - return proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.DecryptRequestOptions; + return proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} + * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} */ -proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -15004,8 +20392,12 @@ proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader = functi var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setSuccess(value); + var value = /** @type {string} */ (reader.readString()); + msg.setComponentName(value); + break; + case 12: + var value = /** @type {string} */ (reader.readString()); + msg.setKeyName(value); break; default: reader.skipField(); @@ -15020,9 +20412,9 @@ proto.dapr.proto.runtime.v1.TryLockResponse.deserializeBinaryFromReader = functi * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.TryLockResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.TryLockResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -15030,37 +20422,62 @@ proto.dapr.proto.runtime.v1.TryLockResponse.prototype.serializeBinary = function /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.TryLockResponse} message + * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TryLockResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getSuccess(); - if (f) { - writer.writeBool( + f = message.getComponentName(); + if (f.length > 0) { + writer.writeString( 1, f ); } + f = message.getKeyName(); + if (f.length > 0) { + writer.writeString( + 12, + f + ); + } }; /** - * optional bool success = 1; - * @return {boolean} + * optional string component_name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.TryLockResponse.prototype.getSuccess = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.getComponentName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {boolean} value - * @return {!proto.dapr.proto.runtime.v1.TryLockResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} returns this */ -proto.dapr.proto.runtime.v1.TryLockResponse.prototype.setSuccess = function(value) { - return jspb.Message.setProto3BooleanField(this, 1, value); +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.setComponentName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string key_name = 12; + * @return {string} + */ +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.getKeyName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 12, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} returns this + */ +proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.setKeyName = function(value) { + return jspb.Message.setProto3StringField(this, 12, value); }; @@ -15080,8 +20497,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnlockRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DecryptResponse.toObject(opt_includeInstance, this); }; @@ -15090,15 +20507,13 @@ proto.dapr.proto.runtime.v1.UnlockRequest.prototype.toObject = function(opt_incl * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnlockRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.DecryptResponse.toObject = function(includeInstance, msg) { var f, obj = { - storeName: jspb.Message.getFieldWithDefault(msg, 1, ""), - resourceId: jspb.Message.getFieldWithDefault(msg, 2, ""), - lockOwner: jspb.Message.getFieldWithDefault(msg, 3, "") + payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) }; if (includeInstance) { @@ -15112,23 +20527,23 @@ proto.dapr.proto.runtime.v1.UnlockRequest.toObject = function(includeInstance, m /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} + * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} */ -proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnlockRequest; - return proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.DecryptResponse; + return proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} + * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} */ -proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -15136,16 +20551,9 @@ proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader = function var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setStoreName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setResourceId(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setLockOwner(value); + var value = new dapr_proto_common_v1_common_pb.StreamPayload; + reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); + msg.setPayload(value); break; default: reader.skipField(); @@ -15160,9 +20568,9 @@ proto.dapr.proto.runtime.v1.UnlockRequest.deserializeBinaryFromReader = function * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnlockRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.DecryptResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -15170,87 +20578,57 @@ proto.dapr.proto.runtime.v1.UnlockRequest.prototype.serializeBinary = function() /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnlockRequest} message + * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnlockRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.DecryptResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStoreName(); - if (f.length > 0) { - writer.writeString( + f = message.getPayload(); + if (f != null) { + writer.writeMessage( 1, - f - ); - } - f = message.getResourceId(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = message.getLockOwner(); - if (f.length > 0) { - writer.writeString( - 3, - f + f, + dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter ); } }; /** - * optional string store_name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getStoreName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this - */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setStoreName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string resource_id = 2; - * @return {string} + * optional dapr.proto.common.v1.StreamPayload payload = 1; + * @return {?proto.dapr.proto.common.v1.StreamPayload} */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getResourceId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.getPayload = function() { + return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 1)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this - */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setResourceId = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); + * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value + * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} returns this +*/ +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.setPayload = function(value) { + return jspb.Message.setWrapperField(this, 1, value); }; /** - * optional string lock_owner = 3; - * @return {string} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} returns this */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.getLockOwner = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.clearPayload = function() { + return this.setPayload(undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.UnlockRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.UnlockRequest.prototype.setLockOwner = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.DecryptResponse.prototype.hasPayload = function() { + return jspb.Message.getField(this, 1) != null; }; @@ -15270,8 +20648,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.UnlockResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.UnlockResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -15280,13 +20658,14 @@ proto.dapr.proto.runtime.v1.UnlockResponse.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnlockResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - status: jspb.Message.getFieldWithDefault(msg, 1, 0) + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -15300,23 +20679,23 @@ proto.dapr.proto.runtime.v1.UnlockResponse.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} */ -proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.UnlockResponse; - return proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetWorkflowRequest; + return proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} */ -proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -15324,8 +20703,12 @@ proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} */ (reader.readEnum()); - msg.setStatus(value); + var value = /** @type {string} */ (reader.readString()); + msg.setInstanceId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); break; default: reader.skipField(); @@ -15340,9 +20723,9 @@ proto.dapr.proto.runtime.v1.UnlockResponse.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.UnlockResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.UnlockResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -15350,47 +20733,62 @@ proto.dapr.proto.runtime.v1.UnlockResponse.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.UnlockResponse} message + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.UnlockResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getStatus(); - if (f !== 0.0) { - writer.writeEnum( + f = message.getInstanceId(); + if (f.length > 0) { + writer.writeString( 1, f ); } + f = message.getWorkflowComponent(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } }; /** - * @enum {number} + * optional string instance_id = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.UnlockResponse.Status = { - SUCCESS: 0, - LOCK_DOES_NOT_EXIST: 1, - LOCK_BELONGS_TO_OTHERS: 2, - INTERNAL_ERROR: 3 +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; + /** - * optional Status status = 1; - * @return {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.UnlockResponse.prototype.getStatus = function() { - return /** @type {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * @param {!proto.dapr.proto.runtime.v1.UnlockResponse.Status} value - * @return {!proto.dapr.proto.runtime.v1.UnlockResponse} returns this + * optional string workflow_component = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.UnlockResponse.prototype.setStatus = function(value) { - return jspb.Message.setProto3EnumField(this, 1, value); +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} returns this + */ +proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; @@ -15410,8 +20808,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetWorkflowResponse.toObject(opt_includeInstance, this); }; @@ -15420,15 +20818,18 @@ proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - name: jspb.Message.getFieldWithDefault(msg, 2, ""), - format: jspb.Message.getFieldWithDefault(msg, 3, 0) + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowName: jspb.Message.getFieldWithDefault(msg, 2, ""), + createdAt: (f = msg.getCreatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), + lastUpdatedAt: (f = msg.getLastUpdatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), + runtimeStatus: jspb.Message.getFieldWithDefault(msg, 5, ""), + propertiesMap: (f = msg.getPropertiesMap()) ? f.toObject(includeInstance, undefined) : [] }; if (includeInstance) { @@ -15442,23 +20843,23 @@ proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleGetKeyRequest; - return proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetWorkflowResponse; + return proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -15467,15 +20868,31 @@ proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader = fu switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setInstanceId(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + msg.setWorkflowName(value); break; case 3: - var value = /** @type {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} */ (reader.readEnum()); - msg.setFormat(value); + var value = new google_protobuf_timestamp_pb.Timestamp; + reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); + msg.setCreatedAt(value); + break; + case 4: + var value = new google_protobuf_timestamp_pb.Timestamp; + reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); + msg.setLastUpdatedAt(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setRuntimeStatus(value); + break; + case 6: + var value = msg.getPropertiesMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; default: reader.skipField(); @@ -15490,9 +20907,9 @@ proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetWorkflowResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -15500,256 +20917,204 @@ proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} message + * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getInstanceId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getName(); + f = message.getWorkflowName(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getFormat(); - if (f !== 0.0) { - writer.writeEnum( + f = message.getCreatedAt(); + if (f != null) { + writer.writeMessage( 3, + f, + google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter + ); + } + f = message.getLastUpdatedAt(); + if (f != null) { + writer.writeMessage( + 4, + f, + google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter + ); + } + f = message.getRuntimeStatus(); + if (f.length > 0) { + writer.writeString( + 5, f ); } + f = message.getPropertiesMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(6, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } }; /** - * @enum {number} - */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat = { - PEM: 0, - JSON: 1 -}; - -/** - * optional string component_name = 1; + * optional string instance_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getComponentName = function() { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getInstanceId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setComponentName = function(value) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setInstanceId = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string name = 2; + * optional string workflow_name = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getName = function() { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getWorkflowName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setName = function(value) { +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setWorkflowName = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional KeyFormat format = 3; - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} + * optional google.protobuf.Timestamp created_at = 3; + * @return {?proto.google.protobuf.Timestamp} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.getFormat = function() { - return /** @type {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getCreatedAt = function() { + return /** @type{?proto.google.protobuf.Timestamp} */ ( + jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 3)); }; /** - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat} value - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleGetKeyRequest.prototype.setFormat = function(value) { - return jspb.Message.setProto3EnumField(this, 3, value); + * @param {?proto.google.protobuf.Timestamp|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setCreatedAt = function(value) { + return jspb.Message.setWrapperField(this, 3, value); }; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearCreatedAt = function() { + return this.setCreatedAt(undefined); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.toObject = function(includeInstance, msg) { - var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, ""), - publicKey: jspb.Message.getFieldWithDefault(msg, 2, "") - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.hasCreatedAt = function() { + return jspb.Message.getField(this, 3) != null; }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} + * optional google.protobuf.Timestamp last_updated_at = 4; + * @return {?proto.google.protobuf.Timestamp} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleGetKeyResponse; - return proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getLastUpdatedAt = function() { + return /** @type{?proto.google.protobuf.Timestamp} */ ( + jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 4)); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} - */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setPublicKey(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; + * @param {?proto.google.protobuf.Timestamp|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setLastUpdatedAt = function(value) { + return jspb.Message.setWrapperField(this, 4, value); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearLastUpdatedAt = function() { + return this.setLastUpdatedAt(undefined); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getPublicKey(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.hasLastUpdatedAt = function() { + return jspb.Message.getField(this, 4) != null; }; /** - * optional string name = 1; + * optional string runtime_status = 5; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getRuntimeStatus = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setRuntimeStatus = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); }; /** - * optional string public_key = 2; - * @return {string} + * map properties = 6; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.getPublicKey = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getPropertiesMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 6, opt_noLazyCreate, + null)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleGetKeyResponse} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleGetKeyResponse.prototype.setPublicKey = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; +proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearPropertiesMap = function() { + this.getPropertiesMap().clear(); + return this;}; @@ -15768,8 +21133,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleEncryptRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.StartWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -15778,18 +21143,17 @@ proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - plaintext: msg.getPlaintext_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), - nonce: msg.getNonce_asB64(), - associatedData: msg.getAssociatedData_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, ""), + workflowName: jspb.Message.getFieldWithDefault(msg, 3, ""), + optionsMap: (f = msg.getOptionsMap()) ? f.toObject(includeInstance, undefined) : [], + input: msg.getInput_asB64() }; if (includeInstance) { @@ -15803,23 +21167,23 @@ proto.dapr.proto.runtime.v1.SubtleEncryptRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleEncryptRequest; - return proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.StartWorkflowRequest; + return proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -15828,27 +21192,25 @@ proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setInstanceId(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setPlaintext(value); + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); + msg.setWorkflowName(value); break; case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); + var value = msg.getOptionsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); break; case 5: var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setNonce(value); - break; - case 6: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setAssociatedData(value); + msg.setInput(value); break; default: reader.skipField(); @@ -15863,9 +21225,9 @@ proto.dapr.proto.runtime.v1.SubtleEncryptRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleEncryptRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.StartWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -15873,234 +21235,162 @@ proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} message + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getInstanceId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getPlaintext_asU8(); + f = message.getWorkflowComponent(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 2, f ); } - f = message.getAlgorithm(); + f = message.getWorkflowName(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getKeyName(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } - f = message.getNonce_asU8(); - if (f.length > 0) { - writer.writeBytes( - 5, - f - ); + f = message.getOptionsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); } - f = message.getAssociatedData_asU8(); + f = message.getInput_asU8(); if (f.length > 0) { writer.writeBytes( - 6, - f - ); - } -}; - - -/** - * optional string component_name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getComponentName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setComponentName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional bytes plaintext = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); + 5, + f + ); + } }; /** - * optional bytes plaintext = 2; - * This is a type-conversion wrapper around `getPlaintext()` + * optional string instance_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getPlaintext())); -}; - - -/** - * optional bytes plaintext = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getPlaintext()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getPlaintext_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getPlaintext())); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setPlaintext = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string algorithm = 3; + * optional string workflow_component = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional string key_name = 4; + * optional string workflow_name = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getWorkflowName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); -}; - - -/** - * optional bytes nonce = 5; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); -}; - - -/** - * optional bytes nonce = 5; - * This is a type-conversion wrapper around `getNonce()` - * @return {string} + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getNonce())); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setWorkflowName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional bytes nonce = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getNonce()` - * @return {!Uint8Array} + * map options = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getNonce_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getNonce())); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getOptionsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + null)); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setNonce = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); -}; +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.clearOptionsMap = function() { + this.getOptionsMap().clear(); + return this;}; /** - * optional bytes associated_data = 6; + * optional bytes input = 5; * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * optional bytes associated_data = 6; - * This is a type-conversion wrapper around `getAssociatedData()` + * optional bytes input = 5; + * This is a type-conversion wrapper around `getInput()` * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData_asB64 = function() { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput_asB64 = function() { return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getAssociatedData())); + this.getInput())); }; /** - * optional bytes associated_data = 6; + * optional bytes input = 5; * Note that Uint8Array is not supported on all browsers. * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getAssociatedData()` + * This is a type-conversion wrapper around `getInput()` * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.getAssociatedData_asU8 = function() { +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput_asU8 = function() { return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getAssociatedData())); + this.getInput())); }; /** * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptRequest.prototype.setAssociatedData = function(value) { - return jspb.Message.setProto3BytesField(this, 6, value); +proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setInput = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); }; @@ -16120,8 +21410,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleEncryptResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.StartWorkflowResponse.toObject(opt_includeInstance, this); }; @@ -16130,14 +21420,13 @@ proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.StartWorkflowResponse.toObject = function(includeInstance, msg) { var f, obj = { - ciphertext: msg.getCiphertext_asB64(), - tag: msg.getTag_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, "") }; if (includeInstance) { @@ -16151,23 +21440,23 @@ proto.dapr.proto.runtime.v1.SubtleEncryptResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleEncryptResponse; - return proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.StartWorkflowResponse; + return proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -16175,12 +21464,8 @@ proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setCiphertext(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTag(value); + var value = /** @type {string} */ (reader.readString()); + msg.setInstanceId(value); break; default: reader.skipField(); @@ -16195,9 +21480,9 @@ proto.dapr.proto.runtime.v1.SubtleEncryptResponse.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleEncryptResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.StartWorkflowResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -16205,110 +21490,37 @@ proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} message + * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.StartWorkflowResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getCiphertext_asU8(); + f = message.getInstanceId(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 1, f ); } - f = message.getTag_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } -}; - - -/** - * optional bytes ciphertext = 1; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes ciphertext = 1; - * This is a type-conversion wrapper around `getCiphertext()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getCiphertext())); -}; - - -/** - * optional bytes ciphertext = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getCiphertext()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getCiphertext_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getCiphertext())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} returns this - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.setCiphertext = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); }; /** - * optional bytes tag = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes tag = 2; - * This is a type-conversion wrapper around `getTag()` + * optional string instance_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTag())); -}; - - -/** - * optional bytes tag = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTag()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.getTag_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTag())); +proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleEncryptResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleEncryptResponse.prototype.setTag = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; @@ -16328,8 +21540,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleDecryptRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -16338,19 +21550,14 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - ciphertext: msg.getCiphertext_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), - nonce: msg.getNonce_asB64(), - tag: msg.getTag_asB64(), - associatedData: msg.getAssociatedData_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -16364,23 +21571,23 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} + * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleDecryptRequest; - return proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.TerminateWorkflowRequest; + return proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} + * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -16389,31 +21596,11 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setInstanceId(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setCiphertext(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); - break; - case 4: var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); - break; - case 5: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setNonce(value); - break; - case 6: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTag(value); - break; - case 7: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setAssociatedData(value); + msg.setWorkflowComponent(value); break; default: reader.skipField(); @@ -16428,9 +21615,9 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleDecryptRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -16438,58 +21625,23 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} message + * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getInstanceId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getCiphertext_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getAlgorithm(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getKeyName(); + f = message.getWorkflowComponent(); if (f.length > 0) { writer.writeString( - 4, - f - ); - } - f = message.getNonce_asU8(); - if (f.length > 0) { - writer.writeBytes( - 5, - f - ); - } - f = message.getTag_asU8(); - if (f.length > 0) { - writer.writeBytes( - 6, - f - ); - } - f = message.getAssociatedData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 7, + 2, f ); } @@ -16497,224 +21649,198 @@ proto.dapr.proto.runtime.v1.SubtleDecryptRequest.serializeBinaryToWriter = funct /** - * optional string component_name = 1; + * optional string instance_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getComponentName = function() { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.getInstanceId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setComponentName = function(value) { +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.setInstanceId = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes ciphertext = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes ciphertext = 2; - * This is a type-conversion wrapper around `getCiphertext()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getCiphertext())); -}; - - -/** - * optional bytes ciphertext = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getCiphertext()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getCiphertext_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getCiphertext())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setCiphertext = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; - - -/** - * optional string algorithm = 3; + * optional string workflow_component = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional string key_name = 4; - * @return {string} + * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); -}; - -/** - * optional bytes nonce = 5; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); -}; +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * optional bytes nonce = 5; - * This is a type-conversion wrapper around `getNonce()` - * @return {string} + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getNonce())); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PauseWorkflowRequest.toObject(opt_includeInstance, this); }; /** - * optional bytes nonce = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getNonce()` - * @return {!Uint8Array} + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getNonce_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getNonce())); -}; - +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.toObject = function(includeInstance, msg) { + var f, obj = { + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") + }; -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setNonce = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * optional bytes tag = 6; - * @return {!(string|Uint8Array)} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.PauseWorkflowRequest; + return proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** - * optional bytes tag = 6; - * This is a type-conversion wrapper around `getTag()` - * @return {string} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTag())); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setInstanceId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional bytes tag = 6; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTag()` + * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getTag_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTag())); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.PauseWorkflowRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setTag = function(value) { - return jspb.Message.setProto3BytesField(this, 6, value); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getInstanceId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getWorkflowComponent(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } }; /** - * optional bytes associated_data = 7; - * @return {!(string|Uint8Array)} + * optional string instance_id = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional bytes associated_data = 7; - * This is a type-conversion wrapper around `getAssociatedData()` - * @return {string} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getAssociatedData())); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes associated_data = 7; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getAssociatedData()` - * @return {!Uint8Array} + * optional string workflow_component = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.getAssociatedData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getAssociatedData())); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptRequest.prototype.setAssociatedData = function(value) { - return jspb.Message.setProto3BytesField(this, 7, value); +proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; @@ -16734,8 +21860,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleDecryptResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -16744,13 +21870,14 @@ proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - plaintext: msg.getPlaintext_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -16764,23 +21891,23 @@ proto.dapr.proto.runtime.v1.SubtleDecryptResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} + * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleDecryptResponse; - return proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ResumeWorkflowRequest; + return proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} + * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -16788,8 +21915,12 @@ proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setPlaintext(value); + var value = /** @type {string} */ (reader.readString()); + msg.setInstanceId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); break; default: reader.skipField(); @@ -16804,9 +21935,9 @@ proto.dapr.proto.runtime.v1.SubtleDecryptResponse.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleDecryptResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -16814,61 +21945,62 @@ proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} message + * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPlaintext_asU8(); + f = message.getInstanceId(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 1, f ); } + f = message.getWorkflowComponent(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } }; /** - * optional bytes plaintext = 1; - * @return {!(string|Uint8Array)} + * optional string instance_id = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional bytes plaintext = 1; - * This is a type-conversion wrapper around `getPlaintext()` - * @return {string} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getPlaintext())); +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes plaintext = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getPlaintext()` - * @return {!Uint8Array} + * optional string workflow_component = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.getPlaintext_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getPlaintext())); +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleDecryptResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleDecryptResponse.prototype.setPlaintext = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; @@ -16888,8 +22020,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -16898,18 +22030,16 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - plaintextKey: msg.getPlaintextKey_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), - nonce: msg.getNonce_asB64(), - associatedData: msg.getAssociatedData_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, ""), + eventName: jspb.Message.getFieldWithDefault(msg, 3, ""), + eventData: msg.getEventData_asB64() }; if (includeInstance) { @@ -16923,23 +22053,23 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest; - return proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest; + return proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -16948,27 +22078,19 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setInstanceId(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setPlaintextKey(value); + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); + msg.setEventName(value); break; case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); - break; - case 5: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setNonce(value); - break; - case 6: var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setAssociatedData(value); + msg.setEventData(value); break; default: reader.skipField(); @@ -16983,9 +22105,9 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -16993,51 +22115,37 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} message + * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getInstanceId(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getPlaintextKey_asU8(); + f = message.getWorkflowComponent(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 2, f ); } - f = message.getAlgorithm(); + f = message.getEventName(); if (f.length > 0) { writer.writeString( 3, f ); } - f = message.getKeyName(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } - f = message.getNonce_asU8(); - if (f.length > 0) { - writer.writeBytes( - 5, - f - ); - } - f = message.getAssociatedData_asU8(); + f = message.getEventData_asU8(); if (f.length > 0) { writer.writeBytes( - 6, + 4, f ); } @@ -17045,182 +22153,98 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.serializeBinaryToWriter = funct /** - * optional string component_name = 1; + * optional string instance_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getComponentName = function() { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getInstanceId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setComponentName = function(value) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setInstanceId = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes plaintext_key = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes plaintext_key = 2; - * This is a type-conversion wrapper around `getPlaintextKey()` + * optional string workflow_component = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getPlaintextKey())); -}; - - -/** - * optional bytes plaintext_key = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getPlaintextKey()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getPlaintextKey_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getPlaintextKey())); +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setPlaintextKey = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; /** - * optional string algorithm = 3; + * optional string event_name = 3; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAlgorithm = function() { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setAlgorithm = function(value) { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setEventName = function(value) { return jspb.Message.setProto3StringField(this, 3, value); }; /** - * optional string key_name = 4; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); -}; - - -/** - * optional bytes nonce = 5; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); -}; - - -/** - * optional bytes nonce = 5; - * This is a type-conversion wrapper around `getNonce()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getNonce())); -}; - - -/** - * optional bytes nonce = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getNonce()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getNonce_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getNonce())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setNonce = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); -}; - - -/** - * optional bytes associated_data = 6; + * optional bytes event_data = 4; * @return {!(string|Uint8Array)} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** - * optional bytes associated_data = 6; - * This is a type-conversion wrapper around `getAssociatedData()` + * optional bytes event_data = 4; + * This is a type-conversion wrapper around `getEventData()` * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData_asB64 = function() { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData_asB64 = function() { return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getAssociatedData())); + this.getEventData())); }; /** - * optional bytes associated_data = 6; + * optional bytes event_data = 4; * Note that Uint8Array is not supported on all browsers. * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getAssociatedData()` + * This is a type-conversion wrapper around `getEventData()` * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.getAssociatedData_asU8 = function() { +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData_asU8 = function() { return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getAssociatedData())); + this.getEventData())); }; /** * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyRequest.prototype.setAssociatedData = function(value) { - return jspb.Message.setProto3BytesField(this, 6, value); +proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setEventData = function(value) { + return jspb.Message.setProto3BytesField(this, 4, value); }; @@ -17240,8 +22264,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.toObject(opt_includeInstance, this); }; @@ -17250,14 +22274,14 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.toObject = function(includeInstance, msg) { var f, obj = { - wrappedKey: msg.getWrappedKey_asB64(), - tag: msg.getTag_asB64() + instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), + workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -17271,23 +22295,23 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} + * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse; - return proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.PurgeWorkflowRequest; + return proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} + * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -17295,12 +22319,12 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setWrappedKey(value); + var value = /** @type {string} */ (reader.readString()); + msg.setInstanceId(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTag(value); + var value = /** @type {string} */ (reader.readString()); + msg.setWorkflowComponent(value); break; default: reader.skipField(); @@ -17315,9 +22339,9 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -17325,22 +22349,22 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} message + * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getWrappedKey_asU8(); + f = message.getInstanceId(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 1, f ); } - f = message.getTag_asU8(); + f = message.getWorkflowComponent(); if (f.length > 0) { - writer.writeBytes( + writer.writeString( 2, f ); @@ -17349,86 +22373,139 @@ proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.serializeBinaryToWriter = func /** - * optional bytes wrapped_key = 1; - * @return {!(string|Uint8Array)} + * optional string instance_id = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.getInstanceId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * optional bytes wrapped_key = 1; - * This is a type-conversion wrapper around `getWrappedKey()` + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} returns this + */ +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.setInstanceId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string workflow_component = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getWrappedKey())); +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.getWorkflowComponent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} returns this + */ +proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.setWorkflowComponent = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); }; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * optional bytes wrapped_key = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getWrappedKey()` - * @return {!Uint8Array} + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getWrappedKey_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getWrappedKey())); +proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ShutdownRequest.toObject(opt_includeInstance, this); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} returns this + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.setWrappedKey = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.ShutdownRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * optional bytes tag = 2; - * @return {!(string|Uint8Array)} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.ShutdownRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.ShutdownRequest; + return proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinaryFromReader(msg, reader); }; /** - * optional bytes tag = 2; - * This is a type-conversion wrapper around `getTag()` - * @return {string} + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.ShutdownRequest} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTag())); +proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional bytes tag = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTag()` + * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.getTag_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTag())); +proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.ShutdownRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse} returns this + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleWrapKeyResponse.prototype.setTag = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.ShutdownRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; }; @@ -17448,8 +22525,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.Job.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.Job.toObject(opt_includeInstance, this); }; @@ -17458,19 +22535,19 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.toObject = function * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.Job} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.Job.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - wrappedKey: msg.getWrappedKey_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), - nonce: msg.getNonce_asB64(), - tag: msg.getTag_asB64(), - associatedData: msg.getAssociatedData_asB64() + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + schedule: jspb.Message.getFieldWithDefault(msg, 2, ""), + repeats: jspb.Message.getFieldWithDefault(msg, 3, 0), + dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), + ttl: jspb.Message.getFieldWithDefault(msg, 5, ""), + data: (f = msg.getData()) && google_protobuf_any_pb.Any.toObject(includeInstance, f), + failurePolicy: (f = msg.getFailurePolicy()) && dapr_proto_common_v1_common_pb.JobFailurePolicy.toObject(includeInstance, f) }; if (includeInstance) { @@ -17484,23 +22561,23 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.toObject = function(includeIn /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.Job} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.Job.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest; - return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.Job; + return proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.Job} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} + * @return {!proto.dapr.proto.runtime.v1.Job} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -17509,31 +22586,33 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader = switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setName(value); break; case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setWrappedKey(value); + var value = /** @type {string} */ (reader.readString()); + msg.setSchedule(value); break; case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); + var value = /** @type {number} */ (reader.readUint32()); + msg.setRepeats(value); break; case 4: var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); + msg.setDueTime(value); break; case 5: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setNonce(value); + var value = /** @type {string} */ (reader.readString()); + msg.setTtl(value); break; case 6: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setTag(value); + var value = new google_protobuf_any_pb.Any; + reader.readMessage(value,google_protobuf_any_pb.Any.deserializeBinaryFromReader); + msg.setData(value); break; case 7: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setAssociatedData(value); + var value = new dapr_proto_common_v1_common_pb.JobFailurePolicy; + reader.readMessage(value,dapr_proto_common_v1_common_pb.JobFailurePolicy.deserializeBinaryFromReader); + msg.setFailurePolicy(value); break; default: reader.skipField(); @@ -17548,9 +22627,9 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.Job.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -17558,283 +22637,299 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.serializeBinary = f /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} message + * @param {!proto.dapr.proto.runtime.v1.Job} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getWrappedKey_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = /** @type {string} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeString( 2, f ); } - f = message.getAlgorithm(); - if (f.length > 0) { - writer.writeString( + f = /** @type {number} */ (jspb.Message.getField(message, 3)); + if (f != null) { + writer.writeUint32( 3, f ); } - f = message.getKeyName(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 4)); + if (f != null) { writer.writeString( 4, f ); } - f = message.getNonce_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = /** @type {string} */ (jspb.Message.getField(message, 5)); + if (f != null) { + writer.writeString( 5, f ); } - f = message.getTag_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = message.getData(); + if (f != null) { + writer.writeMessage( 6, - f + f, + google_protobuf_any_pb.Any.serializeBinaryToWriter ); } - f = message.getAssociatedData_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = message.getFailurePolicy(); + if (f != null) { + writer.writeMessage( 7, - f + f, + dapr_proto_common_v1_common_pb.JobFailurePolicy.serializeBinaryToWriter ); } }; /** - * optional string component_name = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getComponentName = function() { +proto.dapr.proto.runtime.v1.Job.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setComponentName = function(value) { +proto.dapr.proto.runtime.v1.Job.prototype.setName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional bytes wrapped_key = 2; - * @return {!(string|Uint8Array)} + * optional string schedule = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.Job.prototype.getSchedule = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.Job} returns this + */ +proto.dapr.proto.runtime.v1.Job.prototype.setSchedule = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this + */ +proto.dapr.proto.runtime.v1.Job.prototype.clearSchedule = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.Job.prototype.hasSchedule = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * optional uint32 repeats = 3; + * @return {number} + */ +proto.dapr.proto.runtime.v1.Job.prototype.getRepeats = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); }; /** - * optional bytes wrapped_key = 2; - * This is a type-conversion wrapper around `getWrappedKey()` - * @return {string} + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getWrappedKey())); +proto.dapr.proto.runtime.v1.Job.prototype.setRepeats = function(value) { + return jspb.Message.setField(this, 3, value); }; /** - * optional bytes wrapped_key = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getWrappedKey()` - * @return {!Uint8Array} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getWrappedKey_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getWrappedKey())); +proto.dapr.proto.runtime.v1.Job.prototype.clearRepeats = function() { + return jspb.Message.setField(this, 3, undefined); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setWrappedKey = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); +proto.dapr.proto.runtime.v1.Job.prototype.hasRepeats = function() { + return jspb.Message.getField(this, 3) != null; }; /** - * optional string algorithm = 3; + * optional string due_time = 4; * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.Job.prototype.getDueTime = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.Job.prototype.setDueTime = function(value) { + return jspb.Message.setField(this, 4, value); }; /** - * optional string key_name = 4; - * @return {string} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.Job.prototype.clearDueTime = function() { + return jspb.Message.setField(this, 4, undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.Job.prototype.hasDueTime = function() { + return jspb.Message.getField(this, 4) != null; }; /** - * optional bytes nonce = 5; - * @return {!(string|Uint8Array)} + * optional string ttl = 5; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.Job.prototype.getTtl = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); }; /** - * optional bytes nonce = 5; - * This is a type-conversion wrapper around `getNonce()` - * @return {string} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getNonce())); +proto.dapr.proto.runtime.v1.Job.prototype.setTtl = function(value) { + return jspb.Message.setField(this, 5, value); }; /** - * optional bytes nonce = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getNonce()` - * @return {!Uint8Array} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getNonce_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getNonce())); +proto.dapr.proto.runtime.v1.Job.prototype.clearTtl = function() { + return jspb.Message.setField(this, 5, undefined); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setNonce = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); +proto.dapr.proto.runtime.v1.Job.prototype.hasTtl = function() { + return jspb.Message.getField(this, 5) != null; }; /** - * optional bytes tag = 6; - * @return {!(string|Uint8Array)} + * optional google.protobuf.Any data = 6; + * @return {?proto.google.protobuf.Any} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +proto.dapr.proto.runtime.v1.Job.prototype.getData = function() { + return /** @type{?proto.google.protobuf.Any} */ ( + jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 6)); }; /** - * optional bytes tag = 6; - * This is a type-conversion wrapper around `getTag()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getTag())); + * @param {?proto.google.protobuf.Any|undefined} value + * @return {!proto.dapr.proto.runtime.v1.Job} returns this +*/ +proto.dapr.proto.runtime.v1.Job.prototype.setData = function(value) { + return jspb.Message.setWrapperField(this, 6, value); }; /** - * optional bytes tag = 6; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getTag()` - * @return {!Uint8Array} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getTag_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getTag())); +proto.dapr.proto.runtime.v1.Job.prototype.clearData = function() { + return this.setData(undefined); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setTag = function(value) { - return jspb.Message.setProto3BytesField(this, 6, value); +proto.dapr.proto.runtime.v1.Job.prototype.hasData = function() { + return jspb.Message.getField(this, 6) != null; }; /** - * optional bytes associated_data = 7; - * @return {!(string|Uint8Array)} + * optional dapr.proto.common.v1.JobFailurePolicy failure_policy = 7; + * @return {?proto.dapr.proto.common.v1.JobFailurePolicy} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +proto.dapr.proto.runtime.v1.Job.prototype.getFailurePolicy = function() { + return /** @type{?proto.dapr.proto.common.v1.JobFailurePolicy} */ ( + jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.JobFailurePolicy, 7)); }; /** - * optional bytes associated_data = 7; - * This is a type-conversion wrapper around `getAssociatedData()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getAssociatedData())); + * @param {?proto.dapr.proto.common.v1.JobFailurePolicy|undefined} value + * @return {!proto.dapr.proto.runtime.v1.Job} returns this +*/ +proto.dapr.proto.runtime.v1.Job.prototype.setFailurePolicy = function(value) { + return jspb.Message.setWrapperField(this, 7, value); }; /** - * optional bytes associated_data = 7; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getAssociatedData()` - * @return {!Uint8Array} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.Job} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.getAssociatedData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getAssociatedData())); +proto.dapr.proto.runtime.v1.Job.prototype.clearFailurePolicy = function() { + return this.setFailurePolicy(undefined); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyRequest.prototype.setAssociatedData = function(value) { - return jspb.Message.setProto3BytesField(this, 7, value); +proto.dapr.proto.runtime.v1.Job.prototype.hasFailurePolicy = function() { + return jspb.Message.getField(this, 7) != null; }; @@ -17854,8 +22949,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ScheduleJobRequest.toObject(opt_includeInstance, this); }; @@ -17864,13 +22959,14 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.toObject = functio * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ScheduleJobRequest.toObject = function(includeInstance, msg) { var f, obj = { - plaintextKey: msg.getPlaintextKey_asB64() + job: (f = msg.getJob()) && proto.dapr.proto.runtime.v1.Job.toObject(includeInstance, f), + overwrite: jspb.Message.getBooleanFieldWithDefault(msg, 2, false) }; if (includeInstance) { @@ -17884,23 +22980,23 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.toObject = function(includeI /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse; - return proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ScheduleJobRequest; + return proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -17908,8 +23004,13 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setPlaintextKey(value); + var value = new proto.dapr.proto.runtime.v1.Job; + reader.readMessage(value,proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader); + msg.setJob(value); + break; + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setOverwrite(value); break; default: reader.skipField(); @@ -17924,9 +23025,9 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ScheduleJobRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -17934,16 +23035,24 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} message + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ScheduleJobRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPlaintextKey_asU8(); - if (f.length > 0) { - writer.writeBytes( + f = message.getJob(); + if (f != null) { + writer.writeMessage( 1, + f, + proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter + ); + } + f = message.getOverwrite(); + if (f) { + writer.writeBool( + 2, f ); } @@ -17951,44 +23060,57 @@ proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.serializeBinaryToWriter = fu /** - * optional bytes plaintext_key = 1; - * @return {!(string|Uint8Array)} + * optional Job job = 1; + * @return {?proto.dapr.proto.runtime.v1.Job} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.getJob = function() { + return /** @type{?proto.dapr.proto.runtime.v1.Job} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.Job, 1)); }; /** - * optional bytes plaintext_key = 1; - * This is a type-conversion wrapper around `getPlaintextKey()` - * @return {string} + * @param {?proto.dapr.proto.runtime.v1.Job|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} returns this +*/ +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.setJob = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getPlaintextKey())); +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.clearJob = function() { + return this.setJob(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.hasJob = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * optional bytes plaintext_key = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getPlaintextKey()` - * @return {!Uint8Array} + * optional bool overwrite = 2; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.getPlaintextKey_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getPlaintextKey())); +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.getOverwrite = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false)); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse} returns this + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleUnwrapKeyResponse.prototype.setPlaintextKey = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.setOverwrite = function(value) { + return jspb.Message.setProto3BooleanField(this, 2, value); }; @@ -18008,8 +23130,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleSignRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ScheduleJobResponse.toObject(opt_includeInstance, this); }; @@ -18018,16 +23140,13 @@ proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.toObject = function(opt_ * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ScheduleJobResponse.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - digest: msg.getDigest_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, "") + }; if (includeInstance) { @@ -18041,45 +23160,29 @@ proto.dapr.proto.runtime.v1.SubtleSignRequest.toObject = function(includeInstanc /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleSignRequest; - return proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ScheduleJobResponse; + return proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} + * @return {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setDigest(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); - break; default: reader.skipField(); break; @@ -18093,9 +23196,9 @@ proto.dapr.proto.runtime.v1.SubtleSignRequest.deserializeBinaryFromReader = func * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleSignRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ScheduleJobResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -18103,136 +23206,12 @@ proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.serializeBinary = functi /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleSignRequest} message + * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ScheduleJobResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getDigest_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getAlgorithm(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getKeyName(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } -}; - - -/** - * optional string component_name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getComponentName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setComponentName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional bytes digest = 2; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * optional bytes digest = 2; - * This is a type-conversion wrapper around `getDigest()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getDigest())); -}; - - -/** - * optional bytes digest = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getDigest()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getDigest_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getDigest())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setDigest = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; - - -/** - * optional string algorithm = 3; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional string key_name = 4; - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleSignRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleSignRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); }; @@ -18252,8 +23231,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleSignResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetJobRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetJobRequest.toObject(opt_includeInstance, this); }; @@ -18262,13 +23241,13 @@ proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetJobRequest.toObject = function(includeInstance, msg) { var f, obj = { - signature: msg.getSignature_asB64() + name: jspb.Message.getFieldWithDefault(msg, 1, "") }; if (includeInstance) { @@ -18282,23 +23261,23 @@ proto.dapr.proto.runtime.v1.SubtleSignResponse.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} + * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleSignResponse; - return proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetJobRequest; + return proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} + * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -18306,8 +23285,8 @@ proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader = fun var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setSignature(value); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; default: reader.skipField(); @@ -18322,9 +23301,9 @@ proto.dapr.proto.runtime.v1.SubtleSignResponse.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetJobRequest.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleSignResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetJobRequest.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -18332,61 +23311,37 @@ proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleSignResponse} message + * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetJobRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getSignature_asU8(); + f = message.getName(); if (f.length > 0) { - writer.writeBytes( - 1, - f - ); - } -}; - - -/** - * optional bytes signature = 1; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * optional bytes signature = 1; - * This is a type-conversion wrapper around `getSignature()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getSignature())); + writer.writeString( + 1, + f + ); + } }; /** - * optional bytes signature = 1; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getSignature()` - * @return {!Uint8Array} + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.getSignature_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getSignature())); +proto.dapr.proto.runtime.v1.GetJobRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleSignResponse} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleSignResponse.prototype.setSignature = function(value) { - return jspb.Message.setProto3BytesField(this, 1, value); +proto.dapr.proto.runtime.v1.GetJobRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; @@ -18406,8 +23361,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleVerifyRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.GetJobResponse.toObject(opt_includeInstance, this); }; @@ -18416,17 +23371,13 @@ proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.GetJobResponse.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - digest: msg.getDigest_asB64(), - algorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 4, ""), - signature: msg.getSignature_asB64() + job: (f = msg.getJob()) && proto.dapr.proto.runtime.v1.Job.toObject(includeInstance, f) }; if (includeInstance) { @@ -18440,23 +23391,23 @@ proto.dapr.proto.runtime.v1.SubtleVerifyRequest.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} + * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleVerifyRequest; - return proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.GetJobResponse; + return proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} + * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -18464,24 +23415,9 @@ proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader = fu var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setDigest(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setAlgorithm(value); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); - break; - case 5: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setSignature(value); + var value = new proto.dapr.proto.runtime.v1.Job; + reader.readMessage(value,proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader); + msg.setJob(value); break; default: reader.skipField(); @@ -18496,9 +23432,9 @@ proto.dapr.proto.runtime.v1.SubtleVerifyRequest.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleVerifyRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.GetJobResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -18506,185 +23442,187 @@ proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} message + * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.GetJobResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); - if (f.length > 0) { - writer.writeString( + f = message.getJob(); + if (f != null) { + writer.writeMessage( 1, - f - ); - } - f = message.getDigest_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = message.getAlgorithm(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getKeyName(); - if (f.length > 0) { - writer.writeString( - 4, - f - ); - } - f = message.getSignature_asU8(); - if (f.length > 0) { - writer.writeBytes( - 5, - f + f, + proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter ); } }; /** - * optional string component_name = 1; - * @return {string} + * optional Job job = 1; + * @return {?proto.dapr.proto.runtime.v1.Job} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getComponentName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.getJob = function() { + return /** @type{?proto.dapr.proto.runtime.v1.Job} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.Job, 1)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setComponentName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); + * @param {?proto.dapr.proto.runtime.v1.Job|undefined} value + * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} returns this +*/ +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.setJob = function(value) { + return jspb.Message.setWrapperField(this, 1, value); }; /** - * optional bytes digest = 2; - * @return {!(string|Uint8Array)} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} returns this */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.clearJob = function() { + return this.setJob(undefined); }; /** - * optional bytes digest = 2; - * This is a type-conversion wrapper around `getDigest()` - * @return {string} + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getDigest())); +proto.dapr.proto.runtime.v1.GetJobResponse.prototype.hasJob = function() { + return jspb.Message.getField(this, 1) != null; }; -/** - * optional bytes digest = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getDigest()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getDigest_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getDigest())); -}; - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this - */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setDigest = function(value) { - return jspb.Message.setProto3BytesField(this, 2, value); -}; +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * optional string algorithm = 3; - * @return {string} + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DeleteJobRequest.toObject(opt_includeInstance, this); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.DeleteJobRequest.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * optional string key_name = 4; - * @return {string} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.DeleteJobRequest; + return proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader(msg, reader); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 4, value); +proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * optional bytes signature = 5; - * @return {!(string|Uint8Array)} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * optional bytes signature = 5; - * This is a type-conversion wrapper around `getSignature()` - * @return {string} + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getSignature())); +proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } }; /** - * optional bytes signature = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getSignature()` - * @return {!Uint8Array} + * optional string name = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.getSignature_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getSignature())); +proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} returns this */ -proto.dapr.proto.runtime.v1.SubtleVerifyRequest.prototype.setSignature = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); +proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; @@ -18704,8 +23642,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.SubtleVerifyResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.DeleteJobResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.DeleteJobResponse.toObject(opt_includeInstance, this); }; @@ -18714,13 +23652,13 @@ proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.DeleteJobResponse.toObject = function(includeInstance, msg) { var f, obj = { - valid: jspb.Message.getBooleanFieldWithDefault(msg, 1, false) + }; if (includeInstance) { @@ -18734,33 +23672,29 @@ proto.dapr.proto.runtime.v1.SubtleVerifyResponse.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} + * @return {!proto.dapr.proto.runtime.v1.DeleteJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.SubtleVerifyResponse; - return proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.DeleteJobResponse; + return proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} + * @return {!proto.dapr.proto.runtime.v1.DeleteJobResponse} */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { - case 1: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setValid(value); - break; default: reader.skipField(); break; @@ -18774,9 +23708,9 @@ proto.dapr.proto.runtime.v1.SubtleVerifyResponse.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.DeleteJobResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.SubtleVerifyResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.DeleteJobResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -18784,40 +23718,22 @@ proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} message + * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.DeleteJobResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getValid(); - if (f) { - writer.writeBool( - 1, - f - ); - } }; -/** - * optional bool valid = 1; - * @return {boolean} - */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.getValid = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); -}; - /** - * @param {boolean} value - * @return {!proto.dapr.proto.runtime.v1.SubtleVerifyResponse} returns this + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.SubtleVerifyResponse.prototype.setValid = function(value) { - return jspb.Message.setProto3BooleanField(this, 1, value); -}; - - +proto.dapr.proto.runtime.v1.ConversationRequest.repeatedFields_ = [3]; @@ -18834,8 +23750,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.EncryptRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationRequest.toObject(opt_includeInstance, this); }; @@ -18844,14 +23760,20 @@ proto.dapr.proto.runtime.v1.EncryptRequest.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationRequest} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.EncryptRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationRequest.toObject = function(includeInstance, msg) { var f, obj = { - options: (f = msg.getOptions()) && proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject(includeInstance, f), - payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contextid: jspb.Message.getFieldWithDefault(msg, 2, ""), + inputsList: jspb.Message.toObjectList(msg.getInputsList(), + proto.dapr.proto.runtime.v1.ConversationInput.toObject, includeInstance), + parametersMap: (f = msg.getParametersMap()) ? f.toObject(includeInstance, proto.google.protobuf.Any.toObject) : [], + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + scrubpii: jspb.Message.getBooleanFieldWithDefault(msg, 6, false), + temperature: jspb.Message.getFloatingPointFieldWithDefault(msg, 7, 0.0) }; if (includeInstance) { @@ -18865,23 +23787,23 @@ proto.dapr.proto.runtime.v1.EncryptRequest.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} */ -proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationRequest.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.EncryptRequest; - return proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationRequest; + return proto.dapr.proto.runtime.v1.ConversationRequest.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationRequest} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} */ -proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -18889,14 +23811,37 @@ proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.EncryptRequestOptions; - reader.readMessage(value,proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader); - msg.setOptions(value); + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); break; case 2: - var value = new dapr_proto_common_v1_common_pb.StreamPayload; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); - msg.setPayload(value); + var value = /** @type {string} */ (reader.readString()); + msg.setContextid(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.ConversationInput; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationInput.deserializeBinaryFromReader); + msg.addInputs(value); + break; + case 4: + var value = msg.getParametersMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.google.protobuf.Any.deserializeBinaryFromReader, "", new proto.google.protobuf.Any()); + }); + break; + case 5: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 6: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setScrubpii(value); + break; + case 7: + var value = /** @type {number} */ (reader.readDouble()); + msg.setTemperature(value); break; default: reader.skipField(); @@ -18908,69 +23853,232 @@ proto.dapr.proto.runtime.v1.EncryptRequest.deserializeBinaryFromReader = functio /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.ConversationRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.ConversationRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.ConversationRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = /** @type {string} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeString( + 2, + f + ); + } + f = message.getInputsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.ConversationInput.serializeBinaryToWriter + ); + } + f = message.getParametersMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Any.serializeBinaryToWriter); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = /** @type {boolean} */ (jspb.Message.getField(message, 6)); + if (f != null) { + writer.writeBool( + 6, + f + ); + } + f = /** @type {number} */ (jspb.Message.getField(message, 7)); + if (f != null) { + writer.writeDouble( + 7, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string contextID = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getContextid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.setContextid = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearContextid = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.hasContextid = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated ConversationInput inputs = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getInputsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationInput, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.setInputsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationInput=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.EncryptRequest.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.addInputs = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.ConversationInput, opt_index); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.EncryptRequest} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getOptions(); - if (f != null) { - writer.writeMessage( - 1, - f, - proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter - ); - } - f = message.getPayload(); - if (f != null) { - writer.writeMessage( - 2, - f, - dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter - ); - } +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearInputsList = function() { + return this.setInputsList([]); }; /** - * optional EncryptRequestOptions options = 1; - * @return {?proto.dapr.proto.runtime.v1.EncryptRequestOptions} + * map parameters = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.getOptions = function() { - return /** @type{?proto.dapr.proto.runtime.v1.EncryptRequestOptions} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.EncryptRequestOptions, 1)); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getParametersMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + proto.google.protobuf.Any)); }; /** - * @param {?proto.dapr.proto.runtime.v1.EncryptRequestOptions|undefined} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this -*/ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.setOptions = function(value) { - return jspb.Message.setWrapperField(this, 1, value); + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearParametersMap = function() { + this.getParametersMap().clear(); + return this;}; + + +/** + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearOptions = function() { - return this.setOptions(undefined); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; + + +/** + * optional bool scrubPII = 6; + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getScrubpii = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 6, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.setScrubpii = function(value) { + return jspb.Message.setField(this, 6, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearScrubpii = function() { + return jspb.Message.setField(this, 6, undefined); }; @@ -18978,36 +24086,35 @@ proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearOptions = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.hasOptions = function() { - return jspb.Message.getField(this, 1) != null; +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.hasScrubpii = function() { + return jspb.Message.getField(this, 6) != null; }; /** - * optional dapr.proto.common.v1.StreamPayload payload = 2; - * @return {?proto.dapr.proto.common.v1.StreamPayload} + * optional double temperature = 7; + * @return {number} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.getPayload = function() { - return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.getTemperature = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 7, 0.0)); }; /** - * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this -*/ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.setPayload = function(value) { - return jspb.Message.setWrapperField(this, 2, value); + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.setTemperature = function(value) { + return jspb.Message.setField(this, 7, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequest} returns this + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequest} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearPayload = function() { - return this.setPayload(undefined); +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.clearTemperature = function() { + return jspb.Message.setField(this, 7, undefined); }; @@ -19015,12 +24122,19 @@ proto.dapr.proto.runtime.v1.EncryptRequest.prototype.clearPayload = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptRequest.prototype.hasPayload = function() { - return jspb.Message.getField(this, 2) != null; +proto.dapr.proto.runtime.v1.ConversationRequest.prototype.hasTemperature = function() { + return jspb.Message.getField(this, 7) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.repeatedFields_ = [3,8]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -19036,8 +24150,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.toObject(opt_includeInstance, this); }; @@ -19046,18 +24160,23 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 2, ""), - keyWrapAlgorithm: jspb.Message.getFieldWithDefault(msg, 3, ""), - dataEncryptionCipher: jspb.Message.getFieldWithDefault(msg, 10, ""), - omitDecryptionKeyName: jspb.Message.getBooleanFieldWithDefault(msg, 11, false), - decryptionKeyName: jspb.Message.getFieldWithDefault(msg, 12, "") + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contextId: jspb.Message.getFieldWithDefault(msg, 2, ""), + inputsList: jspb.Message.toObjectList(msg.getInputsList(), + proto.dapr.proto.runtime.v1.ConversationInputAlpha2.toObject, includeInstance), + parametersMap: (f = msg.getParametersMap()) ? f.toObject(includeInstance, proto.google.protobuf.Any.toObject) : [], + metadataMap: (f = msg.getMetadataMap()) ? f.toObject(includeInstance, undefined) : [], + scrubPii: jspb.Message.getBooleanFieldWithDefault(msg, 6, false), + temperature: jspb.Message.getFloatingPointFieldWithDefault(msg, 7, 0.0), + toolsList: jspb.Message.toObjectList(msg.getToolsList(), + proto.dapr.proto.runtime.v1.ConversationTools.toObject, includeInstance), + toolChoice: jspb.Message.getFieldWithDefault(msg, 9, "") }; if (includeInstance) { @@ -19071,23 +24190,23 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.EncryptRequestOptions; - return proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationRequestAlpha2; + return proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -19096,27 +24215,45 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader = switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + msg.setName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); + msg.setContextId(value); break; case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyWrapAlgorithm(value); + var value = new proto.dapr.proto.runtime.v1.ConversationInputAlpha2; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationInputAlpha2.deserializeBinaryFromReader); + msg.addInputs(value); break; - case 10: - var value = /** @type {string} */ (reader.readString()); - msg.setDataEncryptionCipher(value); + case 4: + var value = msg.getParametersMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.google.protobuf.Any.deserializeBinaryFromReader, "", new proto.google.protobuf.Any()); + }); break; - case 11: + case 5: + var value = msg.getMetadataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 6: var value = /** @type {boolean} */ (reader.readBool()); - msg.setOmitDecryptionKeyName(value); + msg.setScrubPii(value); break; - case 12: + case 7: + var value = /** @type {number} */ (reader.readDouble()); + msg.setTemperature(value); + break; + case 8: + var value = new proto.dapr.proto.runtime.v1.ConversationTools; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationTools.deserializeBinaryFromReader); + msg.addTools(value); + break; + case 9: var value = /** @type {string} */ (reader.readString()); - msg.setDecryptionKeyName(value); + msg.setToolChoice(value); break; default: reader.skipField(); @@ -19131,9 +24268,9 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -19141,51 +24278,68 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} message + * @param {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getKeyName(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 2)); + if (f != null) { writer.writeString( 2, f ); } - f = message.getKeyWrapAlgorithm(); + f = message.getInputsList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 3, - f + f, + proto.dapr.proto.runtime.v1.ConversationInputAlpha2.serializeBinaryToWriter ); } - f = message.getDataEncryptionCipher(); - if (f.length > 0) { - writer.writeString( - 10, + f = message.getParametersMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Any.serializeBinaryToWriter); + } + f = message.getMetadataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(5, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = /** @type {boolean} */ (jspb.Message.getField(message, 6)); + if (f != null) { + writer.writeBool( + 6, f ); } - f = message.getOmitDecryptionKeyName(); - if (f) { - writer.writeBool( - 11, + f = /** @type {number} */ (jspb.Message.getField(message, 7)); + if (f != null) { + writer.writeDouble( + 7, f ); } - f = message.getDecryptionKeyName(); + f = message.getToolsList(); if (f.length > 0) { + writer.writeRepeatedMessage( + 8, + f, + proto.dapr.proto.runtime.v1.ConversationTools.serializeBinaryToWriter + ); + } + f = /** @type {string} */ (jspb.Message.getField(message, 9)); + if (f != null) { writer.writeString( - 12, + 9, f ); } @@ -19193,252 +24347,275 @@ proto.dapr.proto.runtime.v1.EncryptRequestOptions.serializeBinaryToWriter = func /** - * optional string component_name = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getComponentName = function() { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setComponentName = function(value) { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string key_name = 2; + * optional string context_id = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getKeyName = function() { +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getContextId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setContextId = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearContextId = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.hasContextId = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated ConversationInputAlpha2 inputs = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getInputsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationInputAlpha2, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setInputsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.addInputs = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.ConversationInputAlpha2, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearInputsList = function() { + return this.setInputsList([]); +}; + + +/** + * map parameters = 4; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getParametersMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 4, opt_noLazyCreate, + proto.google.protobuf.Any)); }; /** - * optional string key_wrap_algorithm = 3; - * @return {string} + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getKeyWrapAlgorithm = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearParametersMap = function() { + this.getParametersMap().clear(); + return this;}; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * map metadata = 5; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setKeyWrapAlgorithm = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getMetadataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 5, opt_noLazyCreate, + null)); }; /** - * optional string data_encryption_cipher = 10; - * @return {string} + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getDataEncryptionCipher = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 10, "")); -}; +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearMetadataMap = function() { + this.getMetadataMap().clear(); + return this;}; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * optional bool scrub_pii = 6; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setDataEncryptionCipher = function(value) { - return jspb.Message.setProto3StringField(this, 10, value); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getScrubPii = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 6, false)); }; /** - * optional bool omit_decryption_key_name = 11; - * @return {boolean} + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getOmitDecryptionKeyName = function() { - return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 11, false)); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setScrubPii = function(value) { + return jspb.Message.setField(this, 6, value); }; /** - * @param {boolean} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setOmitDecryptionKeyName = function(value) { - return jspb.Message.setProto3BooleanField(this, 11, value); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearScrubPii = function() { + return jspb.Message.setField(this, 6, undefined); }; /** - * optional string decryption_key_name = 12; - * @return {string} + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.getDecryptionKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 12, "")); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.hasScrubPii = function() { + return jspb.Message.getField(this, 6) != null; }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.EncryptRequestOptions} returns this + * optional double temperature = 7; + * @return {number} */ -proto.dapr.proto.runtime.v1.EncryptRequestOptions.prototype.setDecryptionKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 12, value); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getTemperature = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 7, 0.0)); }; +/** + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setTemperature = function(value) { + return jspb.Message.setField(this, 7, value); +}; - -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.EncryptResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearTemperature = function() { + return jspb.Message.setField(this, 7, undefined); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptResponse.toObject = function(includeInstance, msg) { - var f, obj = { - payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.hasTemperature = function() { + return jspb.Message.getField(this, 7) != null; }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} + * repeated ConversationTools tools = 8; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.EncryptResponse; - return proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getToolsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationTools, 8)); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} - */ -proto.dapr.proto.runtime.v1.EncryptResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = new dapr_proto_common_v1_common_pb.StreamPayload; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); - msg.setPayload(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setToolsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 8, value); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * @param {!proto.dapr.proto.runtime.v1.ConversationTools=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationTools} */ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.EncryptResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.addTools = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 8, opt_value, proto.dapr.proto.runtime.v1.ConversationTools, opt_index); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.EncryptResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getPayload(); - if (f != null) { - writer.writeMessage( - 1, - f, - dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter - ); - } +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearToolsList = function() { + return this.setToolsList([]); }; /** - * optional dapr.proto.common.v1.StreamPayload payload = 1; - * @return {?proto.dapr.proto.common.v1.StreamPayload} + * optional string tool_choice = 9; + * @return {string} */ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.getPayload = function() { - return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 1)); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.getToolChoice = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 9, "")); }; /** - * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value - * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} returns this -*/ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.setPayload = function(value) { - return jspb.Message.setWrapperField(this, 1, value); + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.setToolChoice = function(value) { + return jspb.Message.setField(this, 9, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.EncryptResponse} returns this + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationRequestAlpha2} returns this */ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.clearPayload = function() { - return this.setPayload(undefined); +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.clearToolChoice = function() { + return jspb.Message.setField(this, 9, undefined); }; @@ -19446,8 +24623,8 @@ proto.dapr.proto.runtime.v1.EncryptResponse.prototype.clearPayload = function() * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.EncryptResponse.prototype.hasPayload = function() { - return jspb.Message.getField(this, 1) != null; +proto.dapr.proto.runtime.v1.ConversationRequestAlpha2.prototype.hasToolChoice = function() { + return jspb.Message.getField(this, 9) != null; }; @@ -19467,8 +24644,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DecryptRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationInput.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationInput.toObject(opt_includeInstance, this); }; @@ -19477,14 +24654,15 @@ proto.dapr.proto.runtime.v1.DecryptRequest.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationInput} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationInput.toObject = function(includeInstance, msg) { var f, obj = { - options: (f = msg.getOptions()) && proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject(includeInstance, f), - payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) + content: jspb.Message.getFieldWithDefault(msg, 1, ""), + role: jspb.Message.getFieldWithDefault(msg, 2, ""), + scrubpii: jspb.Message.getBooleanFieldWithDefault(msg, 3, false) }; if (includeInstance) { @@ -19498,23 +24676,23 @@ proto.dapr.proto.runtime.v1.DecryptRequest.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} */ -proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationInput.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DecryptRequest; - return proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationInput; + return proto.dapr.proto.runtime.v1.ConversationInput.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationInput} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} */ -proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationInput.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -19522,14 +24700,16 @@ proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.DecryptRequestOptions; - reader.readMessage(value,proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader); - msg.setOptions(value); + var value = /** @type {string} */ (reader.readString()); + msg.setContent(value); break; case 2: - var value = new dapr_proto_common_v1_common_pb.StreamPayload; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); - msg.setPayload(value); + var value = /** @type {string} */ (reader.readString()); + msg.setRole(value); + break; + case 3: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setScrubpii(value); break; default: reader.skipField(); @@ -19544,9 +24724,9 @@ proto.dapr.proto.runtime.v1.DecryptRequest.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationInput.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DecryptRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationInput.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -19554,56 +24734,78 @@ proto.dapr.proto.runtime.v1.DecryptRequest.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DecryptRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationInput} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationInput.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getOptions(); - if (f != null) { - writer.writeMessage( + f = message.getContent(); + if (f.length > 0) { + writer.writeString( 1, - f, - proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter + f ); } - f = message.getPayload(); + f = /** @type {string} */ (jspb.Message.getField(message, 2)); if (f != null) { - writer.writeMessage( + writer.writeString( 2, - f, - dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter + f + ); + } + f = /** @type {boolean} */ (jspb.Message.getField(message, 3)); + if (f != null) { + writer.writeBool( + 3, + f ); } }; /** - * optional DecryptRequestOptions options = 1; - * @return {?proto.dapr.proto.runtime.v1.DecryptRequestOptions} + * optional string content = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.getOptions = function() { - return /** @type{?proto.dapr.proto.runtime.v1.DecryptRequestOptions} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.DecryptRequestOptions, 1)); +proto.dapr.proto.runtime.v1.ConversationInput.prototype.getContent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {?proto.dapr.proto.runtime.v1.DecryptRequestOptions|undefined} value - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this -*/ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.setOptions = function(value) { - return jspb.Message.setWrapperField(this, 1, value); + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInput.prototype.setContent = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this + * optional string role = 2; + * @return {string} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearOptions = function() { - return this.setOptions(undefined); +proto.dapr.proto.runtime.v1.ConversationInput.prototype.getRole = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInput.prototype.setRole = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInput.prototype.clearRole = function() { + return jspb.Message.setField(this, 2, undefined); }; @@ -19611,36 +24813,35 @@ proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearOptions = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.hasOptions = function() { - return jspb.Message.getField(this, 1) != null; +proto.dapr.proto.runtime.v1.ConversationInput.prototype.hasRole = function() { + return jspb.Message.getField(this, 2) != null; }; /** - * optional dapr.proto.common.v1.StreamPayload payload = 2; - * @return {?proto.dapr.proto.common.v1.StreamPayload} + * optional bool scrubPII = 3; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.getPayload = function() { - return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 2)); +proto.dapr.proto.runtime.v1.ConversationInput.prototype.getScrubpii = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 3, false)); }; /** - * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this -*/ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.setPayload = function(value) { - return jspb.Message.setWrapperField(this, 2, value); + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInput.prototype.setScrubpii = function(value) { + return jspb.Message.setField(this, 3, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequest} returns this + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationInput} returns this */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearPayload = function() { - return this.setPayload(undefined); +proto.dapr.proto.runtime.v1.ConversationInput.prototype.clearScrubpii = function() { + return jspb.Message.setField(this, 3, undefined); }; @@ -19648,12 +24849,19 @@ proto.dapr.proto.runtime.v1.DecryptRequest.prototype.clearPayload = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.DecryptRequest.prototype.hasPayload = function() { - return jspb.Message.getField(this, 2) != null; +proto.dapr.proto.runtime.v1.ConversationInput.prototype.hasScrubpii = function() { + return jspb.Message.getField(this, 3) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.repeatedFields_ = [1]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -19669,8 +24877,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationInputAlpha2.toObject(opt_includeInstance, this); }; @@ -19679,14 +24887,15 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.toObject = function(includeInstance, msg) { var f, obj = { - componentName: jspb.Message.getFieldWithDefault(msg, 1, ""), - keyName: jspb.Message.getFieldWithDefault(msg, 12, "") + messagesList: jspb.Message.toObjectList(msg.getMessagesList(), + proto.dapr.proto.runtime.v1.ConversationMessage.toObject, includeInstance), + scrubPii: jspb.Message.getBooleanFieldWithDefault(msg, 2, false) }; if (includeInstance) { @@ -19700,23 +24909,23 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DecryptRequestOptions; - return proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationInputAlpha2; + return proto.dapr.proto.runtime.v1.ConversationInputAlpha2.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -19724,12 +24933,13 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader = var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setComponentName(value); + var value = new proto.dapr.proto.runtime.v1.ConversationMessage; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessage.deserializeBinaryFromReader); + msg.addMessages(value); break; - case 12: - var value = /** @type {string} */ (reader.readString()); - msg.setKeyName(value); + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setScrubPii(value); break; default: reader.skipField(); @@ -19744,9 +24954,9 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationInputAlpha2.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -19754,23 +24964,24 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} message + * @param {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getComponentName(); + f = message.getMessagesList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 1, - f + f, + proto.dapr.proto.runtime.v1.ConversationMessage.serializeBinaryToWriter ); } - f = message.getKeyName(); - if (f.length > 0) { - writer.writeString( - 12, + f = /** @type {boolean} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeBool( + 2, f ); } @@ -19778,42 +24989,109 @@ proto.dapr.proto.runtime.v1.DecryptRequestOptions.serializeBinaryToWriter = func /** - * optional string component_name = 1; - * @return {string} + * repeated ConversationMessage messages = 1; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.getComponentName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.getMessagesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessage, 1)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} returns this + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.setMessagesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationMessage=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.setComponentName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.addMessages = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.ConversationMessage, opt_index); }; /** - * optional string key_name = 12; - * @return {string} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} returns this */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.getKeyName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 12, "")); +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.clearMessagesList = function() { + return this.setMessagesList([]); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DecryptRequestOptions} returns this + * optional bool scrub_pii = 2; + * @return {boolean} */ -proto.dapr.proto.runtime.v1.DecryptRequestOptions.prototype.setKeyName = function(value) { - return jspb.Message.setProto3StringField(this, 12, value); +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.getScrubPii = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.setScrubPii = function(value) { + return jspb.Message.setField(this, 2, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationInputAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.clearScrubPii = function() { + return jspb.Message.setField(this, 2, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationInputAlpha2.prototype.hasScrubPii = function() { + return jspb.Message.getField(this, 2) != null; }; +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_ = [[1,2,3,4,5]]; + +/** + * @enum {number} + */ +proto.dapr.proto.runtime.v1.ConversationMessage.MessageTypesCase = { + MESSAGE_TYPES_NOT_SET: 0, + OF_DEVELOPER: 1, + OF_SYSTEM: 2, + OF_USER: 3, + OF_ASSISTANT: 4, + OF_TOOL: 5 +}; + +/** + * @return {proto.dapr.proto.runtime.v1.ConversationMessage.MessageTypesCase} + */ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getMessageTypesCase = function() { + return /** @type {proto.dapr.proto.runtime.v1.ConversationMessage.MessageTypesCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0])); +}; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -19829,8 +25107,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DecryptResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessage.toObject(opt_includeInstance, this); }; @@ -19839,13 +25117,17 @@ proto.dapr.proto.runtime.v1.DecryptResponse.prototype.toObject = function(opt_in * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessage} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessage.toObject = function(includeInstance, msg) { var f, obj = { - payload: (f = msg.getPayload()) && dapr_proto_common_v1_common_pb.StreamPayload.toObject(includeInstance, f) + ofDeveloper: (f = msg.getOfDeveloper()) && proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.toObject(includeInstance, f), + ofSystem: (f = msg.getOfSystem()) && proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.toObject(includeInstance, f), + ofUser: (f = msg.getOfUser()) && proto.dapr.proto.runtime.v1.ConversationMessageOfUser.toObject(includeInstance, f), + ofAssistant: (f = msg.getOfAssistant()) && proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.toObject(includeInstance, f), + ofTool: (f = msg.getOfTool()) && proto.dapr.proto.runtime.v1.ConversationMessageOfTool.toObject(includeInstance, f) }; if (includeInstance) { @@ -19859,23 +25141,23 @@ proto.dapr.proto.runtime.v1.DecryptResponse.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} */ -proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessage.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DecryptResponse; - return proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessage; + return proto.dapr.proto.runtime.v1.ConversationMessage.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessage} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} */ -proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessage.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -19883,9 +25165,29 @@ proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader = functi var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new dapr_proto_common_v1_common_pb.StreamPayload; - reader.readMessage(value,dapr_proto_common_v1_common_pb.StreamPayload.deserializeBinaryFromReader); - msg.setPayload(value); + var value = new proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.deserializeBinaryFromReader); + msg.setOfDeveloper(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageOfSystem; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.deserializeBinaryFromReader); + msg.setOfSystem(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageOfUser; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageOfUser.deserializeBinaryFromReader); + msg.setOfUser(value); + break; + case 4: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.deserializeBinaryFromReader); + msg.setOfAssistant(value); + break; + case 5: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageOfTool; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageOfTool.deserializeBinaryFromReader); + msg.setOfTool(value); break; default: reader.skipField(); @@ -19900,9 +25202,9 @@ proto.dapr.proto.runtime.v1.DecryptResponse.deserializeBinaryFromReader = functi * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DecryptResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -19910,48 +25212,80 @@ proto.dapr.proto.runtime.v1.DecryptResponse.prototype.serializeBinary = function /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DecryptResponse} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessage} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DecryptResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getPayload(); + f = message.getOfDeveloper(); if (f != null) { writer.writeMessage( 1, f, - dapr_proto_common_v1_common_pb.StreamPayload.serializeBinaryToWriter + proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.serializeBinaryToWriter + ); + } + f = message.getOfSystem(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.serializeBinaryToWriter + ); + } + f = message.getOfUser(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.dapr.proto.runtime.v1.ConversationMessageOfUser.serializeBinaryToWriter + ); + } + f = message.getOfAssistant(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.serializeBinaryToWriter + ); + } + f = message.getOfTool(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.dapr.proto.runtime.v1.ConversationMessageOfTool.serializeBinaryToWriter ); } }; /** - * optional dapr.proto.common.v1.StreamPayload payload = 1; - * @return {?proto.dapr.proto.common.v1.StreamPayload} + * optional ConversationMessageOfDeveloper of_developer = 1; + * @return {?proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.getPayload = function() { - return /** @type{?proto.dapr.proto.common.v1.StreamPayload} */ ( - jspb.Message.getWrapperField(this, dapr_proto_common_v1_common_pb.StreamPayload, 1)); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getOfDeveloper = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper, 1)); }; /** - * @param {?proto.dapr.proto.common.v1.StreamPayload|undefined} value - * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} returns this + * @param {?proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.setPayload = function(value) { - return jspb.Message.setWrapperField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.setOfDeveloper = function(value) { + return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0], value); }; /** * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.DecryptResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.clearPayload = function() { - return this.setPayload(undefined); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.clearOfDeveloper = function() { + return this.setOfDeveloper(undefined); }; @@ -19959,172 +25293,167 @@ proto.dapr.proto.runtime.v1.DecryptResponse.prototype.clearPayload = function() * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.DecryptResponse.prototype.hasPayload = function() { +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.hasOfDeveloper = function() { return jspb.Message.getField(this, 1) != null; }; +/** + * optional ConversationMessageOfSystem of_system = 2; + * @return {?proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} + */ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getOfSystem = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageOfSystem, 2)); +}; + +/** + * @param {?proto.dapr.proto.runtime.v1.ConversationMessageOfSystem|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.setOfSystem = function(value) { + return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0], value); +}; -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.clearOfSystem = function() { + return this.setOfSystem(undefined); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.toObject = function(includeInstance, msg) { - var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") - }; +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.hasOfSystem = function() { + return jspb.Message.getField(this, 2) != null; +}; - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; + +/** + * optional ConversationMessageOfUser of_user = 3; + * @return {?proto.dapr.proto.runtime.v1.ConversationMessageOfUser} + */ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getOfUser = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationMessageOfUser} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageOfUser, 3)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.ConversationMessageOfUser|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.setOfUser = function(value) { + return jspb.Message.setOneofWrapperField(this, 3, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.clearOfUser = function() { + return this.setOfUser(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.hasOfUser = function() { + return jspb.Message.getField(this, 3) != null; }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} + * optional ConversationMessageOfAssistant of_assistant = 4; + * @return {?proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetWorkflowRequest; - return proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getOfAssistant = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant, 4)); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} - */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; + * @param {?proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.setOfAssistant = function(value) { + return jspb.Message.setOneofWrapperField(this, 4, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0], value); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetWorkflowRequest.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.clearOfAssistant = function() { + return this.setOfAssistant(undefined); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getWorkflowComponent(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.hasOfAssistant = function() { + return jspb.Message.getField(this, 4) != null; }; /** - * optional string instance_id = 1; - * @return {string} + * optional ConversationMessageOfTool of_tool = 5; + * @return {?proto.dapr.proto.runtime.v1.ConversationMessageOfTool} */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.getInstanceId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.getOfTool = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationMessageOfTool} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageOfTool, 5)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); + * @param {?proto.dapr.proto.runtime.v1.ConversationMessageOfTool|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.setOfTool = function(value) { + return jspb.Message.setOneofWrapperField(this, 5, proto.dapr.proto.runtime.v1.ConversationMessage.oneofGroups_[0], value); }; /** - * optional string workflow_component = 2; - * @return {string} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessage} returns this */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.clearOfTool = function() { + return this.setOfTool(undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationMessage.prototype.hasOfTool = function() { + return jspb.Message.getField(this, 5) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -20140,8 +25469,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetWorkflowResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.toObject(opt_includeInstance, this); }; @@ -20150,18 +25479,15 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowName: jspb.Message.getFieldWithDefault(msg, 2, ""), - createdAt: (f = msg.getCreatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), - lastUpdatedAt: (f = msg.getLastUpdatedAt()) && google_protobuf_timestamp_pb.Timestamp.toObject(includeInstance, f), - runtimeStatus: jspb.Message.getFieldWithDefault(msg, 5, ""), - propertiesMap: (f = msg.getPropertiesMap()) ? f.toObject(includeInstance, undefined) : [] + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contentList: jspb.Message.toObjectList(msg.getContentList(), + proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject, includeInstance) }; if (includeInstance) { @@ -20175,23 +25501,23 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetWorkflowResponse; - return proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper; + return proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -20200,31 +25526,12 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader = fu switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowName(value); - break; - case 3: - var value = new google_protobuf_timestamp_pb.Timestamp; - reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); - msg.setCreatedAt(value); - break; - case 4: - var value = new google_protobuf_timestamp_pb.Timestamp; - reader.readMessage(value,google_protobuf_timestamp_pb.Timestamp.deserializeBinaryFromReader); - msg.setLastUpdatedAt(value); - break; - case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setRuntimeStatus(value); - break; - case 6: - var value = msg.getPropertiesMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); + var value = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader); + msg.addContent(value); break; default: reader.skipField(); @@ -20239,9 +25546,9 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetWorkflowResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -20249,154 +25556,54 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } - f = message.getWorkflowName(); + f = message.getContentList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 2, - f - ); - } - f = message.getCreatedAt(); - if (f != null) { - writer.writeMessage( - 3, - f, - google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter - ); - } - f = message.getLastUpdatedAt(); - if (f != null) { - writer.writeMessage( - 4, f, - google_protobuf_timestamp_pb.Timestamp.serializeBinaryToWriter - ); - } - f = message.getRuntimeStatus(); - if (f.length > 0) { - writer.writeString( - 5, - f + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter ); } - f = message.getPropertiesMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(6, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } }; /** - * optional string instance_id = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string workflow_name = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getWorkflowName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setWorkflowName = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); -}; - - -/** - * optional google.protobuf.Timestamp created_at = 3; - * @return {?proto.google.protobuf.Timestamp} - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getCreatedAt = function() { - return /** @type{?proto.google.protobuf.Timestamp} */ ( - jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 3)); -}; - - -/** - * @param {?proto.google.protobuf.Timestamp|undefined} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setCreatedAt = function(value) { - return jspb.Message.setWrapperField(this, 3, value); -}; - - -/** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearCreatedAt = function() { - return this.setCreatedAt(undefined); -}; - - -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.hasCreatedAt = function() { - return jspb.Message.getField(this, 3) != null; -}; - - -/** - * optional google.protobuf.Timestamp last_updated_at = 4; - * @return {?proto.google.protobuf.Timestamp} - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getLastUpdatedAt = function() { - return /** @type{?proto.google.protobuf.Timestamp} */ ( - jspb.Message.getWrapperField(this, google_protobuf_timestamp_pb.Timestamp, 4)); -}; - - -/** - * @param {?proto.google.protobuf.Timestamp|undefined} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this -*/ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setLastUpdatedAt = function(value) { - return jspb.Message.setWrapperField(this, 4, value); + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.setName = function(value) { + return jspb.Message.setField(this, 1, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} returns this */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearLastUpdatedAt = function() { - return this.setLastUpdatedAt(undefined); +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.clearName = function() { + return jspb.Message.setField(this, 1, undefined); }; @@ -20404,53 +25611,57 @@ proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearLastUpdatedAt = f * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.hasLastUpdatedAt = function() { - return jspb.Message.getField(this, 4) != null; +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.hasName = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * optional string runtime_status = 5; - * @return {string} + * repeated ConversationMessageContent content = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getRuntimeStatus = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.getContentList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageContent, 2)); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this - */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.setRuntimeStatus = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.setContentList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); }; /** - * map properties = 6; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.getPropertiesMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 6, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.addContent = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationMessageContent, opt_index); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.GetWorkflowResponse} returns this + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper} returns this */ -proto.dapr.proto.runtime.v1.GetWorkflowResponse.prototype.clearPropertiesMap = function() { - this.getPropertiesMap().clear(); - return this; +proto.dapr.proto.runtime.v1.ConversationMessageOfDeveloper.prototype.clearContentList = function() { + return this.setContentList([]); }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -20466,8 +25677,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.StartWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.toObject(opt_includeInstance, this); }; @@ -20476,17 +25687,15 @@ proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, ""), - workflowName: jspb.Message.getFieldWithDefault(msg, 3, ""), - optionsMap: (f = msg.getOptionsMap()) ? f.toObject(includeInstance, undefined) : [], - input: msg.getInput_asB64() + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contentList: jspb.Message.toObjectList(msg.getContentList(), + proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject, includeInstance) }; if (includeInstance) { @@ -20500,23 +25709,23 @@ proto.dapr.proto.runtime.v1.StartWorkflowRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.StartWorkflowRequest; - return proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageOfSystem; + return proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -20525,25 +25734,12 @@ proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowName(value); - break; - case 4: - var value = msg.getOptionsMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); - }); - break; - case 5: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setInput(value); + var value = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader); + msg.addContent(value); break; default: reader.skipField(); @@ -20558,9 +25754,9 @@ proto.dapr.proto.runtime.v1.StartWorkflowRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.StartWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -20568,166 +25764,111 @@ proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } - f = message.getWorkflowComponent(); + f = message.getContentList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 2, - f - ); - } - f = message.getWorkflowName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getOptionsMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } - f = message.getInput_asU8(); - if (f.length > 0) { - writer.writeBytes( - 5, - f + f, + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter ); } }; /** - * optional string instance_id = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); -}; - - -/** - * optional string workflow_component = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} returns this */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.setName = function(value) { + return jspb.Message.setField(this, 1, value); }; /** - * optional string workflow_name = 3; - * @return {string} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} returns this */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getWorkflowName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.clearName = function() { + return jspb.Message.setField(this, 1, undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setWorkflowName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.hasName = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * map options = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} + * repeated ConversationMessageContent content = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getOptionsMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.getContentList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageContent, 2)); }; /** - * Clears values from the map. The map will be non-null. - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.clearOptionsMap = function() { - this.getOptionsMap().clear(); - return this; + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.setContentList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); }; /** - * optional bytes input = 5; - * @return {!(string|Uint8Array)} + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.addContent = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationMessageContent, opt_index); }; /** - * optional bytes input = 5; - * This is a type-conversion wrapper around `getInput()` - * @return {string} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfSystem} returns this */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getInput())); +proto.dapr.proto.runtime.v1.ConversationMessageOfSystem.prototype.clearContentList = function() { + return this.setContentList([]); }; -/** - * optional bytes input = 5; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getInput()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.getInput_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getInput())); -}; - /** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowRequest} returns this + * List of repeated fields within this message type. + * @private {!Array} + * @const */ -proto.dapr.proto.runtime.v1.StartWorkflowRequest.prototype.setInput = function(value) { - return jspb.Message.setProto3BytesField(this, 5, value); -}; - - +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.repeatedFields_ = [2]; @@ -20744,8 +25885,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.StartWorkflowResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageOfUser.toObject(opt_includeInstance, this); }; @@ -20754,13 +25895,15 @@ proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, "") + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contentList: jspb.Message.toObjectList(msg.getContentList(), + proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject, includeInstance) }; if (includeInstance) { @@ -20774,23 +25917,23 @@ proto.dapr.proto.runtime.v1.StartWorkflowResponse.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.StartWorkflowResponse; - return proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageOfUser; + return proto.dapr.proto.runtime.v1.ConversationMessageOfUser.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -20799,7 +25942,12 @@ proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader = switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setName(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader); + msg.addContent(value); break; default: reader.skipField(); @@ -20811,54 +25959,125 @@ proto.dapr.proto.runtime.v1.StartWorkflowResponse.deserializeBinaryFromReader = /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.ConversationMessageOfUser.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { + writer.writeString( + 1, + f + ); + } + f = message.getContentList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.setName = function(value) { + return jspb.Message.setField(this, 1, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.clearName = function() { + return jspb.Message.setField(this, 1, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.StartWorkflowResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.hasName = function() { + return jspb.Message.getField(this, 1) != null; }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * repeated ConversationMessageContent content = 2; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.getContentList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageContent, 2)); }; /** - * optional string instance_id = 1; - * @return {string} + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.setContentList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.getInstanceId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.addContent = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationMessageContent, opt_index); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.StartWorkflowResponse} returns this + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfUser} returns this */ -proto.dapr.proto.runtime.v1.StartWorkflowResponse.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfUser.prototype.clearContentList = function() { + return this.setContentList([]); }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.repeatedFields_ = [2,3]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -20874,8 +26093,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.toObject(opt_includeInstance, this); }; @@ -20884,14 +26103,17 @@ proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.toObject = functi * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + contentList: jspb.Message.toObjectList(msg.getContentList(), + proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject, includeInstance), + toolCallsList: jspb.Message.toObjectList(msg.getToolCallsList(), + proto.dapr.proto.runtime.v1.ConversationToolCalls.toObject, includeInstance) }; if (includeInstance) { @@ -20905,23 +26127,23 @@ proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.toObject = function(include /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.TerminateWorkflowRequest; - return proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant; + return proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -20930,11 +26152,17 @@ proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setName(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); + var value = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader); + msg.addContent(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.ConversationToolCalls; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationToolCalls.deserializeBinaryFromReader); + msg.addToolCalls(value); break; default: reader.skipField(); @@ -20949,9 +26177,9 @@ proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.deserializeBinaryFromReader * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -20959,66 +26187,158 @@ proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.serializeBinary = /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } - f = message.getWorkflowComponent(); + f = message.getContentList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 2, - f + f, + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter + ); + } + f = message.getToolCallsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.ConversationToolCalls.serializeBinaryToWriter ); } }; /** - * optional string instance_id = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.setName = function(value) { + return jspb.Message.setField(this, 1, value); }; /** - * optional string workflow_component = 2; - * @return {string} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.clearName = function() { + return jspb.Message.setField(this, 1, undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.TerminateWorkflowRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.TerminateWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.hasName = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated ConversationMessageContent content = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.getContentList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageContent, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.setContentList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.addContent = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationMessageContent, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.clearContentList = function() { + return this.setContentList([]); +}; + + +/** + * repeated ConversationToolCalls tool_calls = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.getToolCallsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationToolCalls, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.setToolCallsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCalls=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.addToolCalls = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.ConversationToolCalls, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfAssistant.prototype.clearToolCallsList = function() { + return this.setToolCallsList([]); }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.repeatedFields_ = [3]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -21034,8 +26354,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PauseWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageOfTool.toObject(opt_includeInstance, this); }; @@ -21044,14 +26364,16 @@ proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") + toolId: jspb.Message.getFieldWithDefault(msg, 1, ""), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + contentList: jspb.Message.toObjectList(msg.getContentList(), + proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject, includeInstance) }; if (includeInstance) { @@ -21065,23 +26387,23 @@ proto.dapr.proto.runtime.v1.PauseWorkflowRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PauseWorkflowRequest; - return proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageOfTool; + return proto.dapr.proto.runtime.v1.ConversationMessageOfTool.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -21090,11 +26412,16 @@ proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setToolId(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); + msg.setName(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader); + msg.addContent(value); break; default: reader.skipField(); @@ -21109,9 +26436,9 @@ proto.dapr.proto.runtime.v1.PauseWorkflowRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PauseWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessageOfTool.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21119,68 +26446,157 @@ proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } - f = message.getWorkflowComponent(); + f = message.getName(); if (f.length > 0) { writer.writeString( 2, f ); } + f = message.getContentList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter + ); + } }; /** - * optional string instance_id = 1; + * optional string tool_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.getToolId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} returns this */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.setToolId = function(value) { + return jspb.Message.setField(this, 1, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.clearToolId = function() { + return jspb.Message.setField(this, 1, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.hasToolId = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * repeated ConversationMessageContent content = 3; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.getContentList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationMessageContent, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.setContentList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.addContent = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.dapr.proto.runtime.v1.ConversationMessageContent, opt_index); }; /** - * optional string workflow_component = 2; - * @return {string} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageOfTool} returns this + */ +proto.dapr.proto.runtime.v1.ConversationMessageOfTool.prototype.clearContentList = function() { + return this.setContentList([]); +}; + + + +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationToolCalls.oneofGroups_ = [[2]]; + +/** + * @enum {number} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ConversationToolCalls.ToolTypesCase = { + TOOL_TYPES_NOT_SET: 0, + FUNCTION: 2 }; - /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PauseWorkflowRequest} returns this + * @return {proto.dapr.proto.runtime.v1.ConversationToolCalls.ToolTypesCase} */ -proto.dapr.proto.runtime.v1.PauseWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.getToolTypesCase = function() { + return /** @type {proto.dapr.proto.runtime.v1.ConversationToolCalls.ToolTypesCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.ConversationToolCalls.oneofGroups_[0])); }; - - if (jspb.Message.GENERATE_TO_OBJECT) { /** * Creates an object representation of this proto. @@ -21194,8 +26610,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationToolCalls.toObject(opt_includeInstance, this); }; @@ -21204,14 +26620,14 @@ proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.toObject = function( * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCalls} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationToolCalls.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + pb_function: (f = msg.getFunction()) && proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.toObject(includeInstance, f) }; if (includeInstance) { @@ -21225,23 +26641,23 @@ proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.toObject = function(includeIns /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationToolCalls.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ResumeWorkflowRequest; - return proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationToolCalls; + return proto.dapr.proto.runtime.v1.ConversationToolCalls.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCalls} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationToolCalls.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -21250,11 +26666,12 @@ proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader = switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setId(value); break; case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); + var value = new proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.deserializeBinaryFromReader); + msg.setFunction(value); break; default: reader.skipField(); @@ -21269,9 +26686,9 @@ proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.deserializeBinaryFromReader = * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationToolCalls.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21279,62 +26696,100 @@ proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.serializeBinary = fu /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCalls} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationToolCalls.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } - f = message.getWorkflowComponent(); - if (f.length > 0) { - writer.writeString( + f = message.getFunction(); + if (f != null) { + writer.writeMessage( 2, - f + f, + proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.serializeBinaryToWriter ); } }; /** - * optional string instance_id = 1; + * optional string id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.getId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} returns this */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.setId = function(value) { + return jspb.Message.setField(this, 1, value); }; /** - * optional string workflow_component = 2; - * @return {string} + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} returns this */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.clearId = function() { + return jspb.Message.setField(this, 1, undefined); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.ResumeWorkflowRequest} returns this + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.ResumeWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.hasId = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional ConversationToolCallsOfFunction function = 2; + * @return {?proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} + */ +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.getFunction = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction, 2)); +}; + + +/** + * @param {?proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.setFunction = function(value) { + return jspb.Message.setOneofWrapperField(this, 2, proto.dapr.proto.runtime.v1.ConversationToolCalls.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} returns this + */ +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.clearFunction = function() { + return this.setFunction(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationToolCalls.prototype.hasFunction = function() { + return jspb.Message.getField(this, 2) != null; }; @@ -21354,8 +26809,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.toObject(opt_includeInstance, this); }; @@ -21364,16 +26819,14 @@ proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.toObject = funct * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, ""), - eventName: jspb.Message.getFieldWithDefault(msg, 3, ""), - eventData: msg.getEventData_asB64() + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + arguments: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -21387,23 +26840,23 @@ proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.toObject = function(includ /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest; - return proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction; + return proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -21412,19 +26865,11 @@ proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReade switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); + msg.setName(value); break; case 2: var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setEventName(value); - break; - case 4: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setEventData(value); + msg.setArguments(value); break; default: reader.skipField(); @@ -21439,9 +26884,9 @@ proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.deserializeBinaryFromReade * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21449,139 +26894,65 @@ proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.serializeBinary /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); + f = message.getName(); if (f.length > 0) { writer.writeString( 1, f ); } - f = message.getWorkflowComponent(); + f = message.getArguments(); if (f.length > 0) { writer.writeString( 2, f ); } - f = message.getEventName(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } - f = message.getEventData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 4, - f - ); - } }; /** - * optional string instance_id = 1; + * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getInstanceId = function() { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} returns this */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setInstanceId = function(value) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.setName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; /** - * optional string workflow_component = 2; + * optional string arguments = 2; * @return {string} */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getWorkflowComponent = function() { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.getArguments = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction} returns this */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setWorkflowComponent = function(value) { +proto.dapr.proto.runtime.v1.ConversationToolCallsOfFunction.prototype.setArguments = function(value) { return jspb.Message.setProto3StringField(this, 2, value); }; -/** - * optional string event_name = 3; - * @return {string} - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setEventName = function(value) { - return jspb.Message.setProto3StringField(this, 3, value); -}; - - -/** - * optional bytes event_data = 4; - * @return {!(string|Uint8Array)} - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); -}; - - -/** - * optional bytes event_data = 4; - * This is a type-conversion wrapper around `getEventData()` - * @return {string} - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getEventData())); -}; - - -/** - * optional bytes event_data = 4; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getEventData()` - * @return {!Uint8Array} - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.getEventData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getEventData())); -}; - - -/** - * @param {!(string|Uint8Array)} value - * @return {!proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.RaiseEventWorkflowRequest.prototype.setEventData = function(value) { - return jspb.Message.setProto3BytesField(this, 4, value); -}; - - @@ -21598,8 +26969,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationMessageContent.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject(opt_includeInstance, this); }; @@ -21608,14 +26979,13 @@ proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.toObject = function(o * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationMessageContent.toObject = function(includeInstance, msg) { var f, obj = { - instanceId: jspb.Message.getFieldWithDefault(msg, 1, ""), - workflowComponent: jspb.Message.getFieldWithDefault(msg, 2, "") + text: jspb.Message.getFieldWithDefault(msg, 1, "") }; if (includeInstance) { @@ -21629,23 +26999,23 @@ proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.toObject = function(includeInst /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.PurgeWorkflowRequest; - return proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationMessageContent; + return proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationMessageContent.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -21654,11 +27024,7 @@ proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader = f switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setInstanceId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setWorkflowComponent(value); + msg.setText(value); break; default: reader.skipField(); @@ -21673,9 +27039,9 @@ proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.deserializeBinaryFromReader = f * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationMessageContent.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21683,62 +27049,37 @@ proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.serializeBinary = fun /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationMessageContent} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationMessageContent.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getInstanceId(); - if (f.length > 0) { - writer.writeString( - 1, - f - ); - } - f = message.getWorkflowComponent(); + f = message.getText(); if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * optional string instance_id = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.getInstanceId = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} returns this - */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.setInstanceId = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); + writer.writeString( + 1, + f + ); + } }; /** - * optional string workflow_component = 2; + * optional string text = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.getWorkflowComponent = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +proto.dapr.proto.runtime.v1.ConversationMessageContent.prototype.getText = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.PurgeWorkflowRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationMessageContent} returns this */ -proto.dapr.proto.runtime.v1.PurgeWorkflowRequest.prototype.setWorkflowComponent = function(value) { - return jspb.Message.setProto3StringField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationMessageContent.prototype.setText = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; @@ -21758,8 +27099,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ShutdownRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationResult.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResult.toObject(opt_includeInstance, this); }; @@ -21768,13 +27109,14 @@ proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.toObject = function(opt_in * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationResult} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ShutdownRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationResult.toObject = function(includeInstance, msg) { var f, obj = { - + result: jspb.Message.getFieldWithDefault(msg, 1, ""), + parametersMap: (f = msg.getParametersMap()) ? f.toObject(includeInstance, proto.google.protobuf.Any.toObject) : [] }; if (includeInstance) { @@ -21788,29 +27130,39 @@ proto.dapr.proto.runtime.v1.ShutdownRequest.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ShutdownRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResult} */ -proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationResult.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ShutdownRequest; - return proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationResult; + return proto.dapr.proto.runtime.v1.ConversationResult.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationResult} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ShutdownRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResult} */ -proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationResult.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setResult(value); + break; + case 2: + var value = msg.getParametersMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.google.protobuf.Any.deserializeBinaryFromReader, "", new proto.google.protobuf.Any()); + }); + break; default: reader.skipField(); break; @@ -21824,9 +27176,9 @@ proto.dapr.proto.runtime.v1.ShutdownRequest.deserializeBinaryFromReader = functi * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationResult.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ShutdownRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationResult.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21834,15 +27186,73 @@ proto.dapr.proto.runtime.v1.ShutdownRequest.prototype.serializeBinary = function /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ShutdownRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationResult} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ShutdownRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationResult.serializeBinaryToWriter = function(message, writer) { var f = undefined; + f = message.getResult(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getParametersMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(2, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.google.protobuf.Any.serializeBinaryToWriter); + } +}; + + +/** + * optional string result = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationResult.prototype.getResult = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResult} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResult.prototype.setResult = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * map parameters = 2; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.dapr.proto.runtime.v1.ConversationResult.prototype.getParametersMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 2, opt_noLazyCreate, + proto.google.protobuf.Any)); }; +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationResult} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResult.prototype.clearParametersMap = function() { + this.getParametersMap().clear(); + return this;}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.repeatedFields_ = [1]; @@ -21859,8 +27269,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.Job.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.Job.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResultAlpha2.toObject(opt_includeInstance, this); }; @@ -21869,18 +27279,14 @@ proto.dapr.proto.runtime.v1.Job.prototype.toObject = function(opt_includeInstanc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.Job} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.Job.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.toObject = function(includeInstance, msg) { var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, ""), - schedule: jspb.Message.getFieldWithDefault(msg, 2, ""), - repeats: jspb.Message.getFieldWithDefault(msg, 3, 0), - dueTime: jspb.Message.getFieldWithDefault(msg, 4, ""), - ttl: jspb.Message.getFieldWithDefault(msg, 5, ""), - data: (f = msg.getData()) && google_protobuf_any_pb.Any.toObject(includeInstance, f) + choicesList: jspb.Message.toObjectList(msg.getChoicesList(), + proto.dapr.proto.runtime.v1.ConversationResultChoices.toObject, includeInstance) }; if (includeInstance) { @@ -21894,23 +27300,23 @@ proto.dapr.proto.runtime.v1.Job.toObject = function(includeInstance, msg) { /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.Job} + * @return {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} */ -proto.dapr.proto.runtime.v1.Job.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.Job; - return proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationResultAlpha2; + return proto.dapr.proto.runtime.v1.ConversationResultAlpha2.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.Job} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.Job} + * @return {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} */ -proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -21918,29 +27324,9 @@ proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader = function(msg, read var field = reader.getFieldNumber(); switch (field) { case 1: - var value = /** @type {string} */ (reader.readString()); - msg.setName(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setSchedule(value); - break; - case 3: - var value = /** @type {number} */ (reader.readUint32()); - msg.setRepeats(value); - break; - case 4: - var value = /** @type {string} */ (reader.readString()); - msg.setDueTime(value); - break; - case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setTtl(value); - break; - case 6: - var value = new google_protobuf_any_pb.Any; - reader.readMessage(value,google_protobuf_any_pb.Any.deserializeBinaryFromReader); - msg.setData(value); + var value = new proto.dapr.proto.runtime.v1.ConversationResultChoices; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationResultChoices.deserializeBinaryFromReader); + msg.addChoices(value); break; default: reader.skipField(); @@ -21955,9 +27341,9 @@ proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader = function(msg, read * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.Job.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationResultAlpha2.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -21965,245 +27351,260 @@ proto.dapr.proto.runtime.v1.Job.prototype.serializeBinary = function() { /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.Job} message + * @param {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getName(); + f = message.getChoicesList(); if (f.length > 0) { - writer.writeString( + writer.writeRepeatedMessage( 1, - f - ); - } - f = /** @type {string} */ (jspb.Message.getField(message, 2)); - if (f != null) { - writer.writeString( - 2, - f - ); - } - f = /** @type {number} */ (jspb.Message.getField(message, 3)); - if (f != null) { - writer.writeUint32( - 3, - f - ); - } - f = /** @type {string} */ (jspb.Message.getField(message, 4)); - if (f != null) { - writer.writeString( - 4, - f - ); - } - f = /** @type {string} */ (jspb.Message.getField(message, 5)); - if (f != null) { - writer.writeString( - 5, - f - ); - } - f = message.getData(); - if (f != null) { - writer.writeMessage( - 6, f, - google_protobuf_any_pb.Any.serializeBinaryToWriter + proto.dapr.proto.runtime.v1.ConversationResultChoices.serializeBinaryToWriter ); } }; /** - * optional string name = 1; - * @return {string} - */ -proto.dapr.proto.runtime.v1.Job.prototype.getName = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); -}; - - -/** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * repeated ConversationResultChoices choices = 1; + * @return {!Array} */ -proto.dapr.proto.runtime.v1.Job.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.getChoicesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationResultChoices, 1)); }; /** - * optional string schedule = 2; - * @return {string} - */ -proto.dapr.proto.runtime.v1.Job.prototype.getSchedule = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.setChoicesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * @param {!proto.dapr.proto.runtime.v1.ConversationResultChoices=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} */ -proto.dapr.proto.runtime.v1.Job.prototype.setSchedule = function(value) { - return jspb.Message.setField(this, 2, value); +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.addChoices = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.dapr.proto.runtime.v1.ConversationResultChoices, opt_index); }; /** - * Clears the field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} returns this */ -proto.dapr.proto.runtime.v1.Job.prototype.clearSchedule = function() { - return jspb.Message.setField(this, 2, undefined); +proto.dapr.proto.runtime.v1.ConversationResultAlpha2.prototype.clearChoicesList = function() { + return this.setChoicesList([]); }; -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.dapr.proto.runtime.v1.Job.prototype.hasSchedule = function() { - return jspb.Message.getField(this, 2) != null; -}; - -/** - * optional uint32 repeats = 3; - * @return {number} - */ -proto.dapr.proto.runtime.v1.Job.prototype.getRepeats = function() { - return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); -}; +if (jspb.Message.GENERATE_TO_OBJECT) { /** - * @param {number} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} */ -proto.dapr.proto.runtime.v1.Job.prototype.setRepeats = function(value) { - return jspb.Message.setField(this, 3, value); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResultChoices.toObject(opt_includeInstance, this); }; /** - * Clears the field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Deprecated. Whether to include + * the JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.dapr.proto.runtime.v1.ConversationResultChoices} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.Job.prototype.clearRepeats = function() { - return jspb.Message.setField(this, 3, undefined); -}; - +proto.dapr.proto.runtime.v1.ConversationResultChoices.toObject = function(includeInstance, msg) { + var f, obj = { + finishReason: jspb.Message.getFieldWithDefault(msg, 1, ""), + index: jspb.Message.getFieldWithDefault(msg, 2, 0), + message: (f = msg.getMessage()) && proto.dapr.proto.runtime.v1.ConversationResultMessage.toObject(includeInstance, f) + }; -/** - * Returns whether this field is set. - * @return {boolean} - */ -proto.dapr.proto.runtime.v1.Job.prototype.hasRepeats = function() { - return jspb.Message.getField(this, 3) != null; + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; }; +} /** - * optional string due_time = 4; - * @return {string} + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} */ -proto.dapr.proto.runtime.v1.Job.prototype.getDueTime = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +proto.dapr.proto.runtime.v1.ConversationResultChoices.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.dapr.proto.runtime.v1.ConversationResultChoices; + return proto.dapr.proto.runtime.v1.ConversationResultChoices.deserializeBinaryFromReader(msg, reader); }; /** - * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultChoices} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} */ -proto.dapr.proto.runtime.v1.Job.prototype.setDueTime = function(value) { - return jspb.Message.setField(this, 4, value); +proto.dapr.proto.runtime.v1.ConversationResultChoices.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setFinishReason(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt64()); + msg.setIndex(value); + break; + case 3: + var value = new proto.dapr.proto.runtime.v1.ConversationResultMessage; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationResultMessage.deserializeBinaryFromReader); + msg.setMessage(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; }; /** - * Clears the field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.Job.prototype.clearDueTime = function() { - return jspb.Message.setField(this, 4, undefined); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.dapr.proto.runtime.v1.ConversationResultChoices.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); }; /** - * Returns whether this field is set. - * @return {boolean} + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultChoices} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.Job.prototype.hasDueTime = function() { - return jspb.Message.getField(this, 4) != null; +proto.dapr.proto.runtime.v1.ConversationResultChoices.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getFinishReason(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getIndex(); + if (f !== 0) { + writer.writeInt64( + 2, + f + ); + } + f = message.getMessage(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.dapr.proto.runtime.v1.ConversationResultMessage.serializeBinaryToWriter + ); + } }; /** - * optional string ttl = 5; + * optional string finish_reason = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.Job.prototype.getTtl = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.getFinishReason = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} returns this */ -proto.dapr.proto.runtime.v1.Job.prototype.setTtl = function(value) { - return jspb.Message.setField(this, 5, value); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.setFinishReason = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); }; /** - * Clears the field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * optional int64 index = 2; + * @return {number} */ -proto.dapr.proto.runtime.v1.Job.prototype.clearTtl = function() { - return jspb.Message.setField(this, 5, undefined); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.getIndex = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); }; /** - * Returns whether this field is set. - * @return {boolean} + * @param {number} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} returns this */ -proto.dapr.proto.runtime.v1.Job.prototype.hasTtl = function() { - return jspb.Message.getField(this, 5) != null; +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.setIndex = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); }; /** - * optional google.protobuf.Any data = 6; - * @return {?proto.google.protobuf.Any} + * optional ConversationResultMessage message = 3; + * @return {?proto.dapr.proto.runtime.v1.ConversationResultMessage} */ -proto.dapr.proto.runtime.v1.Job.prototype.getData = function() { - return /** @type{?proto.google.protobuf.Any} */ ( - jspb.Message.getWrapperField(this, google_protobuf_any_pb.Any, 6)); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.getMessage = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationResultMessage} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationResultMessage, 3)); }; /** - * @param {?proto.google.protobuf.Any|undefined} value - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * @param {?proto.dapr.proto.runtime.v1.ConversationResultMessage|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} returns this */ -proto.dapr.proto.runtime.v1.Job.prototype.setData = function(value) { - return jspb.Message.setWrapperField(this, 6, value); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.setMessage = function(value) { + return jspb.Message.setWrapperField(this, 3, value); }; /** * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.Job} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationResultChoices} returns this */ -proto.dapr.proto.runtime.v1.Job.prototype.clearData = function() { - return this.setData(undefined); +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.clearMessage = function() { + return this.setMessage(undefined); }; @@ -22211,12 +27612,19 @@ proto.dapr.proto.runtime.v1.Job.prototype.clearData = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.Job.prototype.hasData = function() { - return jspb.Message.getField(this, 6) != null; +proto.dapr.proto.runtime.v1.ConversationResultChoices.prototype.hasMessage = function() { + return jspb.Message.getField(this, 3) != null; }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationResultMessage.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -22232,8 +27640,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ScheduleJobRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResultMessage.toObject(opt_includeInstance, this); }; @@ -22242,13 +27650,15 @@ proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.toObject = function(opt * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultMessage} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationResultMessage.toObject = function(includeInstance, msg) { var f, obj = { - job: (f = msg.getJob()) && proto.dapr.proto.runtime.v1.Job.toObject(includeInstance, f) + content: jspb.Message.getFieldWithDefault(msg, 1, ""), + toolCallsList: jspb.Message.toObjectList(msg.getToolCallsList(), + proto.dapr.proto.runtime.v1.ConversationToolCalls.toObject, includeInstance) }; if (includeInstance) { @@ -22262,23 +27672,23 @@ proto.dapr.proto.runtime.v1.ScheduleJobRequest.toObject = function(includeInstan /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResultMessage} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationResultMessage.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ScheduleJobRequest; - return proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationResultMessage; + return proto.dapr.proto.runtime.v1.ConversationResultMessage.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationResultMessage} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResultMessage} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationResultMessage.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -22286,9 +27696,13 @@ proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader = fun var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.Job; - reader.readMessage(value,proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader); - msg.setJob(value); + var value = /** @type {string} */ (reader.readString()); + msg.setContent(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ConversationToolCalls; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationToolCalls.deserializeBinaryFromReader); + msg.addToolCalls(value); break; default: reader.skipField(); @@ -22303,9 +27717,9 @@ proto.dapr.proto.runtime.v1.ScheduleJobRequest.deserializeBinaryFromReader = fun * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ScheduleJobRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationResultMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -22313,61 +27727,94 @@ proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.serializeBinary = funct /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationResultMessage} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationResultMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getJob(); - if (f != null) { - writer.writeMessage( + f = message.getContent(); + if (f.length > 0) { + writer.writeString( 1, + f + ); + } + f = message.getToolCallsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, f, - proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter + proto.dapr.proto.runtime.v1.ConversationToolCalls.serializeBinaryToWriter ); } }; /** - * optional Job job = 1; - * @return {?proto.dapr.proto.runtime.v1.Job} + * optional string content = 1; + * @return {string} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.getJob = function() { - return /** @type{?proto.dapr.proto.runtime.v1.Job} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.Job, 1)); +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.getContent = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** - * @param {?proto.dapr.proto.runtime.v1.Job|undefined} value - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} returns this + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResultMessage} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.setContent = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated ConversationToolCalls tool_calls = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.getToolCallsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationToolCalls, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResultMessage} returns this */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.setJob = function(value) { - return jspb.Message.setWrapperField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.setToolCallsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); }; /** - * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobRequest} returns this + * @param {!proto.dapr.proto.runtime.v1.ConversationToolCalls=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationToolCalls} */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.clearJob = function() { - return this.setJob(undefined); +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.addToolCalls = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationToolCalls, opt_index); }; /** - * Returns whether this field is set. - * @return {boolean} + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationResultMessage} returns this */ -proto.dapr.proto.runtime.v1.ScheduleJobRequest.prototype.hasJob = function() { - return jspb.Message.getField(this, 1) != null; +proto.dapr.proto.runtime.v1.ConversationResultMessage.prototype.clearToolCallsList = function() { + return this.setToolCallsList([]); }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationResponse.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -22383,8 +27830,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.ScheduleJobResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResponse.toObject(opt_includeInstance, this); }; @@ -22393,13 +27840,15 @@ proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.toObject = function(op * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationResponse.toObject = function(includeInstance, msg) { var f, obj = { - + contextid: jspb.Message.getFieldWithDefault(msg, 1, ""), + outputsList: jspb.Message.toObjectList(msg.getOutputsList(), + proto.dapr.proto.runtime.v1.ConversationResult.toObject, includeInstance) }; if (includeInstance) { @@ -22413,29 +27862,38 @@ proto.dapr.proto.runtime.v1.ScheduleJobResponse.toObject = function(includeInsta /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.ScheduleJobResponse; - return proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationResponse; + return proto.dapr.proto.runtime.v1.ConversationResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationResponse.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; } var field = reader.getFieldNumber(); switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setContextid(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ConversationResult; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationResult.deserializeBinaryFromReader); + msg.addOutputs(value); + break; default: reader.skipField(); break; @@ -22449,9 +27907,9 @@ proto.dapr.proto.runtime.v1.ScheduleJobResponse.deserializeBinaryFromReader = fu * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.ScheduleJobResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationResponse.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -22459,16 +27917,112 @@ proto.dapr.proto.runtime.v1.ScheduleJobResponse.prototype.serializeBinary = func /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.ScheduleJobResponse} message + * @param {!proto.dapr.proto.runtime.v1.ConversationResponse} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.ScheduleJobResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationResponse.serializeBinaryToWriter = function(message, writer) { var f = undefined; + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { + writer.writeString( + 1, + f + ); + } + f = message.getOutputsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ConversationResult.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string contextID = 1; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.getContextid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.setContextid = function(value) { + return jspb.Message.setField(this, 1, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.clearContextid = function() { + return jspb.Message.setField(this, 1, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.hasContextid = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated ConversationResult outputs = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.getOutputsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationResult, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.setOutputsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationResult=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationResult} + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.addOutputs = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationResult, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationResponse} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResponse.prototype.clearOutputsList = function() { + return this.setOutputsList([]); }; +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.repeatedFields_ = [2]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -22484,8 +28038,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetJobRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetJobRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.toObject(opt_includeInstance, this); }; @@ -22494,13 +28048,15 @@ proto.dapr.proto.runtime.v1.GetJobRequest.prototype.toObject = function(opt_incl * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetJobRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.toObject = function(includeInstance, msg) { var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, "") + contextId: jspb.Message.getFieldWithDefault(msg, 1, ""), + outputsList: jspb.Message.toObjectList(msg.getOutputsList(), + proto.dapr.proto.runtime.v1.ConversationResultAlpha2.toObject, includeInstance) }; if (includeInstance) { @@ -22514,23 +28070,23 @@ proto.dapr.proto.runtime.v1.GetJobRequest.toObject = function(includeInstance, m /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} */ -proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetJobRequest; - return proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationResponseAlpha2; + return proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} */ -proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -22539,7 +28095,12 @@ proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader = function switch (field) { case 1: var value = /** @type {string} */ (reader.readString()); - msg.setName(value); + msg.setContextId(value); + break; + case 2: + var value = new proto.dapr.proto.runtime.v1.ConversationResultAlpha2; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationResultAlpha2.deserializeBinaryFromReader); + msg.addOutputs(value); break; default: reader.skipField(); @@ -22554,9 +28115,9 @@ proto.dapr.proto.runtime.v1.GetJobRequest.deserializeBinaryFromReader = function * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetJobRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetJobRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -22564,41 +28125,130 @@ proto.dapr.proto.runtime.v1.GetJobRequest.prototype.serializeBinary = function() /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetJobRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetJobRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getName(); - if (f.length > 0) { + f = /** @type {string} */ (jspb.Message.getField(message, 1)); + if (f != null) { writer.writeString( 1, f ); } + f = message.getOutputsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.dapr.proto.runtime.v1.ConversationResultAlpha2.serializeBinaryToWriter + ); + } }; /** - * optional string name = 1; + * optional string context_id = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.GetJobRequest.prototype.getName = function() { +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.getContextId = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.GetJobRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} returns this */ -proto.dapr.proto.runtime.v1.GetJobRequest.prototype.setName = function(value) { - return jspb.Message.setProto3StringField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.setContextId = function(value) { + return jspb.Message.setField(this, 1, value); +}; + + +/** + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.clearContextId = function() { + return jspb.Message.setField(this, 1, undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.hasContextId = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated ConversationResultAlpha2 outputs = 2; + * @return {!Array} + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.getOutputsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.dapr.proto.runtime.v1.ConversationResultAlpha2, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.setOutputsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2=} opt_value + * @param {number=} opt_index + * @return {!proto.dapr.proto.runtime.v1.ConversationResultAlpha2} + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.addOutputs = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.dapr.proto.runtime.v1.ConversationResultAlpha2, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.dapr.proto.runtime.v1.ConversationResponseAlpha2} returns this + */ +proto.dapr.proto.runtime.v1.ConversationResponseAlpha2.prototype.clearOutputsList = function() { + return this.setOutputsList([]); }; +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.dapr.proto.runtime.v1.ConversationTools.oneofGroups_ = [[1]]; + +/** + * @enum {number} + */ +proto.dapr.proto.runtime.v1.ConversationTools.ToolTypesCase = { + TOOL_TYPES_NOT_SET: 0, + FUNCTION: 1 +}; + +/** + * @return {proto.dapr.proto.runtime.v1.ConversationTools.ToolTypesCase} + */ +proto.dapr.proto.runtime.v1.ConversationTools.prototype.getToolTypesCase = function() { + return /** @type {proto.dapr.proto.runtime.v1.ConversationTools.ToolTypesCase} */(jspb.Message.computeOneofCase(this, proto.dapr.proto.runtime.v1.ConversationTools.oneofGroups_[0])); +}; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -22614,8 +28264,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.GetJobResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationTools.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationTools.toObject(opt_includeInstance, this); }; @@ -22624,13 +28274,13 @@ proto.dapr.proto.runtime.v1.GetJobResponse.prototype.toObject = function(opt_inc * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationTools} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetJobResponse.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationTools.toObject = function(includeInstance, msg) { var f, obj = { - job: (f = msg.getJob()) && proto.dapr.proto.runtime.v1.Job.toObject(includeInstance, f) + pb_function: (f = msg.getFunction()) && proto.dapr.proto.runtime.v1.ConversationToolsFunction.toObject(includeInstance, f) }; if (includeInstance) { @@ -22644,23 +28294,23 @@ proto.dapr.proto.runtime.v1.GetJobResponse.toObject = function(includeInstance, /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationTools} */ -proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationTools.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.GetJobResponse; - return proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationTools; + return proto.dapr.proto.runtime.v1.ConversationTools.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationTools} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} + * @return {!proto.dapr.proto.runtime.v1.ConversationTools} */ -proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationTools.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -22668,9 +28318,9 @@ proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader = functio var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.dapr.proto.runtime.v1.Job; - reader.readMessage(value,proto.dapr.proto.runtime.v1.Job.deserializeBinaryFromReader); - msg.setJob(value); + var value = new proto.dapr.proto.runtime.v1.ConversationToolsFunction; + reader.readMessage(value,proto.dapr.proto.runtime.v1.ConversationToolsFunction.deserializeBinaryFromReader); + msg.setFunction(value); break; default: reader.skipField(); @@ -22685,9 +28335,9 @@ proto.dapr.proto.runtime.v1.GetJobResponse.deserializeBinaryFromReader = functio * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationTools.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.GetJobResponse.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationTools.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -22695,48 +28345,48 @@ proto.dapr.proto.runtime.v1.GetJobResponse.prototype.serializeBinary = function( /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.GetJobResponse} message + * @param {!proto.dapr.proto.runtime.v1.ConversationTools} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.GetJobResponse.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationTools.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getJob(); + f = message.getFunction(); if (f != null) { writer.writeMessage( 1, f, - proto.dapr.proto.runtime.v1.Job.serializeBinaryToWriter + proto.dapr.proto.runtime.v1.ConversationToolsFunction.serializeBinaryToWriter ); } }; /** - * optional Job job = 1; - * @return {?proto.dapr.proto.runtime.v1.Job} + * optional ConversationToolsFunction function = 1; + * @return {?proto.dapr.proto.runtime.v1.ConversationToolsFunction} */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.getJob = function() { - return /** @type{?proto.dapr.proto.runtime.v1.Job} */ ( - jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.Job, 1)); +proto.dapr.proto.runtime.v1.ConversationTools.prototype.getFunction = function() { + return /** @type{?proto.dapr.proto.runtime.v1.ConversationToolsFunction} */ ( + jspb.Message.getWrapperField(this, proto.dapr.proto.runtime.v1.ConversationToolsFunction, 1)); }; /** - * @param {?proto.dapr.proto.runtime.v1.Job|undefined} value - * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} returns this + * @param {?proto.dapr.proto.runtime.v1.ConversationToolsFunction|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationTools} returns this */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.setJob = function(value) { - return jspb.Message.setWrapperField(this, 1, value); +proto.dapr.proto.runtime.v1.ConversationTools.prototype.setFunction = function(value) { + return jspb.Message.setOneofWrapperField(this, 1, proto.dapr.proto.runtime.v1.ConversationTools.oneofGroups_[0], value); }; /** * Clears the message field making it undefined. - * @return {!proto.dapr.proto.runtime.v1.GetJobResponse} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationTools} returns this */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.clearJob = function() { - return this.setJob(undefined); +proto.dapr.proto.runtime.v1.ConversationTools.prototype.clearFunction = function() { + return this.setFunction(undefined); }; @@ -22744,7 +28394,7 @@ proto.dapr.proto.runtime.v1.GetJobResponse.prototype.clearJob = function() { * Returns whether this field is set. * @return {boolean} */ -proto.dapr.proto.runtime.v1.GetJobResponse.prototype.hasJob = function() { +proto.dapr.proto.runtime.v1.ConversationTools.prototype.hasFunction = function() { return jspb.Message.getField(this, 1) != null; }; @@ -22765,8 +28415,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * http://goto/soy-param-migration * @return {!Object} */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DeleteJobRequest.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.toObject = function(opt_includeInstance) { + return proto.dapr.proto.runtime.v1.ConversationToolsFunction.toObject(opt_includeInstance, this); }; @@ -22775,13 +28425,15 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.toObject = function(opt_i * @param {boolean|undefined} includeInstance Deprecated. Whether to include * the JSPB instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} msg The msg instance to transform. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.toObject = function(includeInstance, msg) { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.toObject = function(includeInstance, msg) { var f, obj = { - name: jspb.Message.getFieldWithDefault(msg, 1, "") + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + description: jspb.Message.getFieldWithDefault(msg, 2, ""), + parameters: (f = msg.getParameters()) && google_protobuf_struct_pb.Struct.toObject(includeInstance, f) }; if (includeInstance) { @@ -22795,23 +28447,23 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.toObject = function(includeInstance /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinary = function(bytes) { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DeleteJobRequest; - return proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.dapr.proto.runtime.v1.ConversationToolsFunction; + return proto.dapr.proto.runtime.v1.ConversationToolsFunction.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} msg The message object to deserialize into. + * @param {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader = function(msg, reader) { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -22822,6 +28474,15 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader = funct var value = /** @type {string} */ (reader.readString()); msg.setName(value); break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setDescription(value); + break; + case 3: + var value = new google_protobuf_struct_pb.Struct; + reader.readMessage(value,google_protobuf_struct_pb.Struct.deserializeBinaryFromReader); + msg.setParameters(value); + break; default: reader.skipField(); break; @@ -22835,9 +28496,9 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.deserializeBinaryFromReader = funct * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.serializeBinary = function() { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter(this, writer); + proto.dapr.proto.runtime.v1.ConversationToolsFunction.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -22845,11 +28506,11 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.serializeBinary = functio /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DeleteJobRequest} message + * @param {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter = function(message, writer) { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.serializeBinaryToWriter = function(message, writer) { var f = undefined; f = message.getName(); if (f.length > 0) { @@ -22858,6 +28519,21 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter = function( f ); } + f = /** @type {string} */ (jspb.Message.getField(message, 2)); + if (f != null) { + writer.writeString( + 2, + f + ); + } + f = message.getParameters(); + if (f != null) { + writer.writeMessage( + 3, + f, + google_protobuf_struct_pb.Struct.serializeBinaryToWriter + ); + } }; @@ -22865,118 +28541,90 @@ proto.dapr.proto.runtime.v1.DeleteJobRequest.serializeBinaryToWriter = function( * optional string name = 1; * @return {string} */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.getName = function() { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.getName = function() { return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; /** * @param {string} value - * @return {!proto.dapr.proto.runtime.v1.DeleteJobRequest} returns this + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} returns this */ -proto.dapr.proto.runtime.v1.DeleteJobRequest.prototype.setName = function(value) { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.setName = function(value) { return jspb.Message.setProto3StringField(this, 1, value); }; +/** + * optional string description = 2; + * @return {string} + */ +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.getDescription = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; - -if (jspb.Message.GENERATE_TO_OBJECT) { /** - * Creates an object representation of this proto. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * Optional fields that are not set will be set to undefined. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * net/proto2/compiler/js/internal/generator.cc#kKeyword. - * @param {boolean=} opt_includeInstance Deprecated. whether to include the - * JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @return {!Object} + * @param {string} value + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} returns this */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.prototype.toObject = function(opt_includeInstance) { - return proto.dapr.proto.runtime.v1.DeleteJobResponse.toObject(opt_includeInstance, this); +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.setDescription = function(value) { + return jspb.Message.setField(this, 2, value); }; /** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Deprecated. Whether to include - * the JSPB instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} msg The msg instance to transform. - * @return {!Object} - * @suppress {unusedLocalVariables} f is only used for nested messages + * Clears the field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} returns this */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.toObject = function(includeInstance, msg) { - var f, obj = { +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.clearDescription = function() { + return jspb.Message.setField(this, 2, undefined); +}; - }; - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.hasDescription = function() { + return jspb.Message.getField(this, 2) != null; }; -} /** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.dapr.proto.runtime.v1.DeleteJobResponse} + * optional google.protobuf.Struct parameters = 3; + * @return {?proto.google.protobuf.Struct} */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.dapr.proto.runtime.v1.DeleteJobResponse; - return proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinaryFromReader(msg, reader); +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.getParameters = function() { + return /** @type{?proto.google.protobuf.Struct} */ ( + jspb.Message.getWrapperField(this, google_protobuf_struct_pb.Struct, 3)); }; /** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.dapr.proto.runtime.v1.DeleteJobResponse} - */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - default: - reader.skipField(); - break; - } - } - return msg; + * @param {?proto.google.protobuf.Struct|undefined} value + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} returns this +*/ +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.setParameters = function(value) { + return jspb.Message.setWrapperField(this, 3, value); }; /** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} + * Clears the message field making it undefined. + * @return {!proto.dapr.proto.runtime.v1.ConversationToolsFunction} returns this */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - proto.dapr.proto.runtime.v1.DeleteJobResponse.serializeBinaryToWriter(this, writer); - return writer.getResultBuffer(); +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.clearParameters = function() { + return this.setParameters(undefined); }; /** - * Serializes the given message to binary data (in protobuf wire - * format), writing to the given BinaryWriter. - * @param {!proto.dapr.proto.runtime.v1.DeleteJobResponse} message - * @param {!jspb.BinaryWriter} writer - * @suppress {unusedLocalVariables} f is only used for nested messages + * Returns whether this field is set. + * @return {boolean} */ -proto.dapr.proto.runtime.v1.DeleteJobResponse.serializeBinaryToWriter = function(message, writer) { - var f = undefined; +proto.dapr.proto.runtime.v1.ConversationToolsFunction.prototype.hasParameters = function() { + return jspb.Message.getField(this, 3) != null; }; diff --git a/src/proto/dapr/proto/sentry/v1/sentry_grpc_pb.js b/src/proto/dapr/proto/sentry/v1/sentry_grpc_pb.js index 30db90c1..756754f5 100644 --- a/src/proto/dapr/proto/sentry/v1/sentry_grpc_pb.js +++ b/src/proto/dapr/proto/sentry/v1/sentry_grpc_pb.js @@ -59,4 +59,4 @@ signCertificate: { }, }; -exports.CAClient = grpc.makeGenericClientConstructor(CAService); +exports.CAClient = grpc.makeGenericClientConstructor(CAService, 'CA'); diff --git a/src/proto/dapr/proto/sentry/v1/sentry_pb.js b/src/proto/dapr/proto/sentry/v1/sentry_pb.js index 8d52a41f..81d6cfa5 100644 --- a/src/proto/dapr/proto/sentry/v1/sentry_pb.js +++ b/src/proto/dapr/proto/sentry/v1/sentry_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js'); goog.object.extend(proto, google_protobuf_timestamp_pb); diff --git a/src/proto/google/protobuf/any_pb.js b/src/proto/google/protobuf/any_pb.js index c9799fca..b9dcb18c 100644 --- a/src/proto/google/protobuf/any_pb.js +++ b/src/proto/google/protobuf/any_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); goog.exportSymbol('proto.google.protobuf.Any', null, global); /** diff --git a/src/proto/google/protobuf/empty_pb.js b/src/proto/google/protobuf/empty_pb.js index 8cabbd24..bcfa1b0c 100644 --- a/src/proto/google/protobuf/empty_pb.js +++ b/src/proto/google/protobuf/empty_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); goog.exportSymbol('proto.google.protobuf.Empty', null, global); /** diff --git a/src/proto/google/protobuf/timestamp_pb.js b/src/proto/google/protobuf/timestamp_pb.js index 88db5c81..da698a63 100644 --- a/src/proto/google/protobuf/timestamp_pb.js +++ b/src/proto/google/protobuf/timestamp_pb.js @@ -13,13 +13,13 @@ var jspb = require('google-protobuf'); var goog = jspb; -var global = - (typeof globalThis !== 'undefined' && globalThis) || - (typeof window !== 'undefined' && window) || - (typeof global !== 'undefined' && global) || - (typeof self !== 'undefined' && self) || - (function () { return this; }).call(null) || - Function('return this')(); +var global = (function() { + if (this) { return this; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + if (typeof self !== 'undefined') { return self; } + return Function('return this')(); +}.call(null)); goog.exportSymbol('proto.google.protobuf.Timestamp', null, global); /**