From 41a8514c0017238dc5d2ffa467de639a9740c875 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 3 Jan 2021 13:46:40 +0000 Subject: [PATCH] Move typescript stuff to static/scripts --- .gitignore | 2 +- package.json | 6 +- .../scripts/{ts => }/_proto/cofd_api_pb.d.ts | 0 static/scripts/{ts => }/_proto/cofd_api_pb.js | 0 .../{ts => }/_proto/cofd_api_pb_service.d.ts | 0 .../{ts => }/_proto/cofd_api_pb_service.js | 0 static/scripts/{ts => }/_proto/cofd_pb.d.ts | 0 static/scripts/{ts => }/_proto/cofd_pb.js | 0 .../{ts => }/_proto/cofd_pb_service.d.ts | 0 .../{ts => }/_proto/cofd_pb_service.js | 0 .../build/_proto_cofd_api_pb_js.bundle.js | 4825 +++++++++++++++++ static/scripts/build/blah.bundle.js | 23 + static/scripts/build/index.bundle.js | 21 + static/scripts/build/runtime.bundle.js | 146 + ...ogle-protobuf_google-protobuf_js.bundle.js | 537 ++ static/scripts/{ts => }/src/blah.ts | 0 static/scripts/{ts => }/src/index.ts | 0 static/scripts/{ts => }/tsconfig.json | 0 static/scripts/{ts => }/webpack.config.js | 4 +- 19 files changed, 5558 insertions(+), 6 deletions(-) rename static/scripts/{ts => }/_proto/cofd_api_pb.d.ts (100%) rename static/scripts/{ts => }/_proto/cofd_api_pb.js (100%) rename static/scripts/{ts => }/_proto/cofd_api_pb_service.d.ts (100%) rename static/scripts/{ts => }/_proto/cofd_api_pb_service.js (100%) rename static/scripts/{ts => }/_proto/cofd_pb.d.ts (100%) rename static/scripts/{ts => }/_proto/cofd_pb.js (100%) rename static/scripts/{ts => }/_proto/cofd_pb_service.d.ts (100%) rename static/scripts/{ts => }/_proto/cofd_pb_service.js (100%) create mode 100644 static/scripts/build/_proto_cofd_api_pb_js.bundle.js create mode 100644 static/scripts/build/blah.bundle.js create mode 100644 static/scripts/build/index.bundle.js create mode 100644 static/scripts/build/runtime.bundle.js create mode 100644 static/scripts/build/vendors-node_modules_google-protobuf_google-protobuf_js.bundle.js rename static/scripts/{ts => }/src/blah.ts (100%) rename static/scripts/{ts => }/src/index.ts (100%) rename static/scripts/{ts => }/tsconfig.json (100%) rename static/scripts/{ts => }/webpack.config.js (93%) diff --git a/.gitignore b/.gitignore index e0a8deb..d0db3e4 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,5 @@ todo.org *.sqlite* *.sqlite.* node_modules -static/scripts/ts/build +static/scripts/dist static/templates/* diff --git a/package.json b/package.json index a3d7d11..cb314ec 100644 --- a/package.json +++ b/package.json @@ -5,9 +5,9 @@ "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1", - "webpack-dev": "cd static/scripts/ts && webpack serve --watch --inline --port 8081 --host 0.0.0.0 --output-path=./build", - "build:protobuf": "mkdir -p static/scripts/ts/_proto && protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts -I ./proto --js_out=import_style=commonjs,binary:./static/scripts/ts/_proto --ts_out=service=grpc-web:./static/scripts/ts/_proto ./proto/*.proto", - "build:webpack": "cd static/scripts/ts && webpack" + "webpack-dev": "cd static/scripts && webpack serve --watch --inline --port 8081 --host 0.0.0.0 --output-path=./build", + "build:protobuf": "mkdir -p static/scripts/_proto && protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts -I ./proto --js_out=import_style=commonjs,binary:./static/scripts/ts/_proto --ts_out=service=grpc-web:./static/scripts/ts/_proto ./proto/*.proto", + "build:webpack": "cd static/scripts && webpack" }, "repository": { "type": "git", diff --git a/static/scripts/ts/_proto/cofd_api_pb.d.ts b/static/scripts/_proto/cofd_api_pb.d.ts similarity index 100% rename from static/scripts/ts/_proto/cofd_api_pb.d.ts rename to static/scripts/_proto/cofd_api_pb.d.ts diff --git a/static/scripts/ts/_proto/cofd_api_pb.js b/static/scripts/_proto/cofd_api_pb.js similarity index 100% rename from static/scripts/ts/_proto/cofd_api_pb.js rename to static/scripts/_proto/cofd_api_pb.js diff --git a/static/scripts/ts/_proto/cofd_api_pb_service.d.ts b/static/scripts/_proto/cofd_api_pb_service.d.ts similarity index 100% rename from static/scripts/ts/_proto/cofd_api_pb_service.d.ts rename to static/scripts/_proto/cofd_api_pb_service.d.ts diff --git a/static/scripts/ts/_proto/cofd_api_pb_service.js b/static/scripts/_proto/cofd_api_pb_service.js similarity index 100% rename from static/scripts/ts/_proto/cofd_api_pb_service.js rename to static/scripts/_proto/cofd_api_pb_service.js diff --git a/static/scripts/ts/_proto/cofd_pb.d.ts b/static/scripts/_proto/cofd_pb.d.ts similarity index 100% rename from static/scripts/ts/_proto/cofd_pb.d.ts rename to static/scripts/_proto/cofd_pb.d.ts diff --git a/static/scripts/ts/_proto/cofd_pb.js b/static/scripts/_proto/cofd_pb.js similarity index 100% rename from static/scripts/ts/_proto/cofd_pb.js rename to static/scripts/_proto/cofd_pb.js diff --git a/static/scripts/ts/_proto/cofd_pb_service.d.ts b/static/scripts/_proto/cofd_pb_service.d.ts similarity index 100% rename from static/scripts/ts/_proto/cofd_pb_service.d.ts rename to static/scripts/_proto/cofd_pb_service.d.ts diff --git a/static/scripts/ts/_proto/cofd_pb_service.js b/static/scripts/_proto/cofd_pb_service.js similarity index 100% rename from static/scripts/ts/_proto/cofd_pb_service.js rename to static/scripts/_proto/cofd_pb_service.js diff --git a/static/scripts/build/_proto_cofd_api_pb_js.bundle.js b/static/scripts/build/_proto_cofd_api_pb_js.bundle.js new file mode 100644 index 0000000..3712473 --- /dev/null +++ b/static/scripts/build/_proto_cofd_api_pb_js.bundle.js @@ -0,0 +1,4825 @@ +(self["webpackChunk"] = self["webpackChunk"] || []).push([["_proto_cofd_api_pb_js"],{ + +/***/ "./_proto/cofd_api_pb.js": +/*!*******************************!*\ + !*** ./_proto/cofd_api_pb.js ***! + \*******************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +// source: cofd_api.proto +/** + * @fileoverview + * @enhanceable + * @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 = __webpack_require__(/*! google-protobuf */ "../../node_modules/google-protobuf/google-protobuf.js"); +var goog = jspb; +var global = Function('return this')(); + +var cofd_pb = __webpack_require__(/*! ./cofd_pb.js */ "./_proto/cofd_pb.js"); +goog.object.extend(proto, cofd_pb); +goog.exportSymbol('proto.models.proto.cofd.api.Attributes', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.BasicInfo', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.Condition', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.SkillSpecializationsUpdate', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.SkillUpdate', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.Skills', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.UpdateAttributeRequest', null, global); +goog.exportSymbol('proto.models.proto.cofd.api.UpdateSkillValueRequest', 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.models.proto.cofd.api.BasicInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.BasicInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.BasicInfo.displayName = 'proto.models.proto.cofd.api.BasicInfo'; +} +/** + * 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.models.proto.cofd.api.Attributes = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.Attributes, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.Attributes.displayName = 'proto.models.proto.cofd.api.Attributes'; +} +/** + * 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.models.proto.cofd.api.UpdateAttributeRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.UpdateAttributeRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.UpdateAttributeRequest.displayName = 'proto.models.proto.cofd.api.UpdateAttributeRequest'; +} +/** + * 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.models.proto.cofd.api.Skills = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.api.Skills.repeatedFields_, null); +}; +goog.inherits(proto.models.proto.cofd.api.Skills, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.Skills.displayName = 'proto.models.proto.cofd.api.Skills'; +} +/** + * 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.models.proto.cofd.api.SkillUpdate = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.SkillUpdate, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.SkillUpdate.displayName = 'proto.models.proto.cofd.api.SkillUpdate'; +} +/** + * 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.models.proto.cofd.api.UpdateSkillValueRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.UpdateSkillValueRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.UpdateSkillValueRequest.displayName = 'proto.models.proto.cofd.api.UpdateSkillValueRequest'; +} +/** + * 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.models.proto.cofd.api.SkillSpecializationsUpdate = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.api.SkillSpecializationsUpdate.repeatedFields_, null); +}; +goog.inherits(proto.models.proto.cofd.api.SkillSpecializationsUpdate, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.SkillSpecializationsUpdate.displayName = 'proto.models.proto.cofd.api.SkillSpecializationsUpdate'; +} +/** + * 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.models.proto.cofd.api.Condition = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.api.Condition, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.api.Condition.displayName = 'proto.models.proto.cofd.api.Condition'; +} + + + +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.models.proto.cofd.api.BasicInfo.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.BasicInfo.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.models.proto.cofd.api.BasicInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.BasicInfo.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + gender: jspb.Message.getFieldWithDefault(msg, 2, ""), + concept: jspb.Message.getFieldWithDefault(msg, 3, ""), + chronicle: jspb.Message.getFieldWithDefault(msg, 4, ""), + age: jspb.Message.getFieldWithDefault(msg, 5, 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.models.proto.cofd.api.BasicInfo} + */ +proto.models.proto.cofd.api.BasicInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.BasicInfo; + return proto.models.proto.cofd.api.BasicInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.BasicInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.BasicInfo} + */ +proto.models.proto.cofd.api.BasicInfo.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.setGender(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setConcept(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setChronicle(value); + break; + case 5: + var value = /** @type {number} */ (reader.readInt32()); + msg.setAge(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.BasicInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.BasicInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.BasicInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getGender(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getConcept(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getChronicle(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getAge(); + if (f !== 0) { + writer.writeInt32( + 5, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.BasicInfo} returns this + */ +proto.models.proto.cofd.api.BasicInfo.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string gender = 2; + * @return {string} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.getGender = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.BasicInfo} returns this + */ +proto.models.proto.cofd.api.BasicInfo.prototype.setGender = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string concept = 3; + * @return {string} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.getConcept = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.BasicInfo} returns this + */ +proto.models.proto.cofd.api.BasicInfo.prototype.setConcept = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string chronicle = 4; + * @return {string} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.getChronicle = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.BasicInfo} returns this + */ +proto.models.proto.cofd.api.BasicInfo.prototype.setChronicle = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional int32 age = 5; + * @return {number} + */ +proto.models.proto.cofd.api.BasicInfo.prototype.getAge = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.BasicInfo} returns this + */ +proto.models.proto.cofd.api.BasicInfo.prototype.setAge = function(value) { + return jspb.Message.setProto3IntField(this, 5, 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.models.proto.cofd.api.Attributes.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.Attributes.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.models.proto.cofd.api.Attributes} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Attributes.toObject = function(includeInstance, msg) { + var f, obj = { + strength: jspb.Message.getFieldWithDefault(msg, 1, 0), + dexterity: jspb.Message.getFieldWithDefault(msg, 2, 0), + stamina: jspb.Message.getFieldWithDefault(msg, 3, 0), + intelligence: jspb.Message.getFieldWithDefault(msg, 4, 0), + wits: jspb.Message.getFieldWithDefault(msg, 5, 0), + resolve: jspb.Message.getFieldWithDefault(msg, 6, 0), + presence: jspb.Message.getFieldWithDefault(msg, 7, 0), + manipulation: jspb.Message.getFieldWithDefault(msg, 8, 0), + composure: jspb.Message.getFieldWithDefault(msg, 9, 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.models.proto.cofd.api.Attributes} + */ +proto.models.proto.cofd.api.Attributes.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.Attributes; + return proto.models.proto.cofd.api.Attributes.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.Attributes} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.Attributes} + */ +proto.models.proto.cofd.api.Attributes.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setStrength(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setDexterity(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setStamina(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setIntelligence(value); + break; + case 5: + var value = /** @type {number} */ (reader.readInt32()); + msg.setWits(value); + break; + case 6: + var value = /** @type {number} */ (reader.readInt32()); + msg.setResolve(value); + break; + case 7: + var value = /** @type {number} */ (reader.readInt32()); + msg.setPresence(value); + break; + case 8: + var value = /** @type {number} */ (reader.readInt32()); + msg.setManipulation(value); + break; + case 9: + var value = /** @type {number} */ (reader.readInt32()); + msg.setComposure(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.Attributes.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.Attributes.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.Attributes} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Attributes.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStrength(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getDexterity(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getStamina(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getIntelligence(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } + f = message.getWits(); + if (f !== 0) { + writer.writeInt32( + 5, + f + ); + } + f = message.getResolve(); + if (f !== 0) { + writer.writeInt32( + 6, + f + ); + } + f = message.getPresence(); + if (f !== 0) { + writer.writeInt32( + 7, + f + ); + } + f = message.getManipulation(); + if (f !== 0) { + writer.writeInt32( + 8, + f + ); + } + f = message.getComposure(); + if (f !== 0) { + writer.writeInt32( + 9, + f + ); + } +}; + + +/** + * optional int32 strength = 1; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getStrength = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setStrength = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 dexterity = 2; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getDexterity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setDexterity = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 stamina = 3; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getStamina = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setStamina = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional int32 intelligence = 4; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getIntelligence = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setIntelligence = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional int32 wits = 5; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getWits = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setWits = function(value) { + return jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional int32 resolve = 6; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getResolve = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setResolve = function(value) { + return jspb.Message.setProto3IntField(this, 6, value); +}; + + +/** + * optional int32 presence = 7; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getPresence = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setPresence = function(value) { + return jspb.Message.setProto3IntField(this, 7, value); +}; + + +/** + * optional int32 manipulation = 8; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getManipulation = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setManipulation = function(value) { + return jspb.Message.setProto3IntField(this, 8, value); +}; + + +/** + * optional int32 composure = 9; + * @return {number} + */ +proto.models.proto.cofd.api.Attributes.prototype.getComposure = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.Attributes} returns this + */ +proto.models.proto.cofd.api.Attributes.prototype.setComposure = function(value) { + return jspb.Message.setProto3IntField(this, 9, 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.models.proto.cofd.api.UpdateAttributeRequest.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.UpdateAttributeRequest.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.models.proto.cofd.api.UpdateAttributeRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.toObject = function(includeInstance, msg) { + var f, obj = { + characterUsername: jspb.Message.getFieldWithDefault(msg, 1, ""), + characterId: jspb.Message.getFieldWithDefault(msg, 2, 0), + attributeName: jspb.Message.getFieldWithDefault(msg, 3, ""), + attributeValue: jspb.Message.getFieldWithDefault(msg, 4, 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.models.proto.cofd.api.UpdateAttributeRequest} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.UpdateAttributeRequest; + return proto.models.proto.cofd.api.UpdateAttributeRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.UpdateAttributeRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.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.setCharacterUsername(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setCharacterId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setAttributeName(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setAttributeValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.UpdateAttributeRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.UpdateAttributeRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCharacterUsername(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getCharacterId(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getAttributeName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getAttributeValue(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } +}; + + +/** + * optional string character_username = 1; + * @return {string} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getCharacterUsername = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setCharacterUsername = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional int32 character_id = 2; + * @return {number} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getCharacterId = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setCharacterId = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional string attribute_name = 3; + * @return {string} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getAttributeName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setAttributeName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional int32 attribute_value = 4; + * @return {number} + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getAttributeValue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this + */ +proto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setAttributeValue = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.models.proto.cofd.api.Skills.repeatedFields_ = [1,2,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.models.proto.cofd.api.Skills.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.Skills.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.models.proto.cofd.api.Skills} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Skills.toObject = function(includeInstance, msg) { + var f, obj = { + physicalSkillsList: jspb.Message.toObjectList(msg.getPhysicalSkillsList(), + cofd_pb.CofdSheet.Skill.toObject, includeInstance), + mentalSkillsList: jspb.Message.toObjectList(msg.getMentalSkillsList(), + cofd_pb.CofdSheet.Skill.toObject, includeInstance), + socialSkillsList: jspb.Message.toObjectList(msg.getSocialSkillsList(), + cofd_pb.CofdSheet.Skill.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.models.proto.cofd.api.Skills} + */ +proto.models.proto.cofd.api.Skills.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.Skills; + return proto.models.proto.cofd.api.Skills.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.Skills} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.Skills} + */ +proto.models.proto.cofd.api.Skills.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new cofd_pb.CofdSheet.Skill; + reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader); + msg.addPhysicalSkills(value); + break; + case 2: + var value = new cofd_pb.CofdSheet.Skill; + reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader); + msg.addMentalSkills(value); + break; + case 3: + var value = new cofd_pb.CofdSheet.Skill; + reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader); + msg.addSocialSkills(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.Skills.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.Skills.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.Skills} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Skills.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPhysicalSkillsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + cofd_pb.CofdSheet.Skill.serializeBinaryToWriter + ); + } + f = message.getMentalSkillsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + cofd_pb.CofdSheet.Skill.serializeBinaryToWriter + ); + } + f = message.getSocialSkillsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + cofd_pb.CofdSheet.Skill.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated models.proto.cofd.CofdSheet.Skill physical_skills = 1; + * @return {!Array} + */ +proto.models.proto.cofd.api.Skills.prototype.getPhysicalSkillsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.api.Skills} returns this +*/ +proto.models.proto.cofd.api.Skills.prototype.setPhysicalSkillsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.api.Skills.prototype.addPhysicalSkills = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.api.Skills} returns this + */ +proto.models.proto.cofd.api.Skills.prototype.clearPhysicalSkillsList = function() { + return this.setPhysicalSkillsList([]); +}; + + +/** + * repeated models.proto.cofd.CofdSheet.Skill mental_skills = 2; + * @return {!Array} + */ +proto.models.proto.cofd.api.Skills.prototype.getMentalSkillsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.api.Skills} returns this +*/ +proto.models.proto.cofd.api.Skills.prototype.setMentalSkillsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.api.Skills.prototype.addMentalSkills = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.api.Skills} returns this + */ +proto.models.proto.cofd.api.Skills.prototype.clearMentalSkillsList = function() { + return this.setMentalSkillsList([]); +}; + + +/** + * repeated models.proto.cofd.CofdSheet.Skill social_skills = 3; + * @return {!Array} + */ +proto.models.proto.cofd.api.Skills.prototype.getSocialSkillsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.api.Skills} returns this +*/ +proto.models.proto.cofd.api.Skills.prototype.setSocialSkillsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.api.Skills.prototype.addSocialSkills = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.api.Skills} returns this + */ +proto.models.proto.cofd.api.Skills.prototype.clearSocialSkillsList = function() { + return this.setSocialSkillsList([]); +}; + + + + + +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.models.proto.cofd.api.SkillUpdate.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.SkillUpdate.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.models.proto.cofd.api.SkillUpdate} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.SkillUpdate.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + skill: (f = msg.getSkill()) && cofd_pb.CofdSheet.Skill.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.models.proto.cofd.api.SkillUpdate} + */ +proto.models.proto.cofd.api.SkillUpdate.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.SkillUpdate; + return proto.models.proto.cofd.api.SkillUpdate.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.SkillUpdate} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.SkillUpdate} + */ +proto.models.proto.cofd.api.SkillUpdate.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 = new cofd_pb.CofdSheet.Skill; + reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader); + msg.setSkill(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.SkillUpdate.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.SkillUpdate} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.SkillUpdate.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getSkill(); + if (f != null) { + writer.writeMessage( + 2, + f, + cofd_pb.CofdSheet.Skill.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional models.proto.cofd.CofdSheet.Skill skill = 2; + * @return {?proto.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.getSkill = function() { + return /** @type{?proto.models.proto.cofd.CofdSheet.Skill} */ ( + jspb.Message.getWrapperField(this, cofd_pb.CofdSheet.Skill, 2)); +}; + + +/** + * @param {?proto.models.proto.cofd.CofdSheet.Skill|undefined} value + * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this +*/ +proto.models.proto.cofd.api.SkillUpdate.prototype.setSkill = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.clearSkill = function() { + return this.setSkill(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.models.proto.cofd.api.SkillUpdate.prototype.hasSkill = 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.models.proto.cofd.api.UpdateSkillValueRequest.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.UpdateSkillValueRequest.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.models.proto.cofd.api.UpdateSkillValueRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.toObject = function(includeInstance, msg) { + var f, obj = { + characterUsername: jspb.Message.getFieldWithDefault(msg, 1, ""), + characterId: jspb.Message.getFieldWithDefault(msg, 2, 0), + skillName: jspb.Message.getFieldWithDefault(msg, 3, ""), + skillValue: jspb.Message.getFieldWithDefault(msg, 4, 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.models.proto.cofd.api.UpdateSkillValueRequest} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.UpdateSkillValueRequest; + return proto.models.proto.cofd.api.UpdateSkillValueRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.UpdateSkillValueRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.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.setCharacterUsername(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setCharacterId(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setSkillName(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setSkillValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.UpdateSkillValueRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.UpdateSkillValueRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCharacterUsername(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getCharacterId(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getSkillName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getSkillValue(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } +}; + + +/** + * optional string character_username = 1; + * @return {string} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getCharacterUsername = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setCharacterUsername = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional int32 character_id = 2; + * @return {number} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getCharacterId = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setCharacterId = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional string skill_name = 3; + * @return {string} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getSkillName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setSkillName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional int32 skill_value = 4; + * @return {number} + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getSkillValue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this + */ +proto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setSkillValue = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.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.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.SkillSpecializationsUpdate.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.models.proto.cofd.api.SkillSpecializationsUpdate} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + specializationsList: (f = jspb.Message.getRepeatedField(msg, 2)) == 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.models.proto.cofd.api.SkillSpecializationsUpdate} + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.SkillSpecializationsUpdate; + return proto.models.proto.cofd.api.SkillSpecializationsUpdate.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.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.addSpecializations(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.SkillSpecializationsUpdate.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getSpecializationsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 2, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated string specializations = 2; + * @return {!Array} + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.getSpecializationsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.setSpecializationsList = function(value) { + return jspb.Message.setField(this, 2, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.addSpecializations = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 2, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this + */ +proto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.clearSpecializationsList = function() { + return this.setSpecializationsList([]); +}; + + + + + +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.models.proto.cofd.api.Condition.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.api.Condition.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.models.proto.cofd.api.Condition} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Condition.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.models.proto.cofd.api.Condition} + */ +proto.models.proto.cofd.api.Condition.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.api.Condition; + return proto.models.proto.cofd.api.Condition.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.api.Condition} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.api.Condition} + */ +proto.models.proto.cofd.api.Condition.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; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.api.Condition.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.api.Condition.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.api.Condition} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.api.Condition.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.api.Condition.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.api.Condition} returns this + */ +proto.models.proto.cofd.api.Condition.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +goog.object.extend(exports, proto.models.proto.cofd.api); + + +/***/ }), + +/***/ "./_proto/cofd_pb.js": +/*!***************************!*\ + !*** ./_proto/cofd_pb.js ***! + \***************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +// source: cofd.proto +/** + * @fileoverview + * @enhanceable + * @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 = __webpack_require__(/*! google-protobuf */ "../../node_modules/google-protobuf/google-protobuf.js"); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.models.proto.cofd.ChangelingFields', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.Attack', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.Condition', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.Item', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.Merit', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.Skill', null, global); +goog.exportSymbol('proto.models.proto.cofd.CofdSheet.SystemFieldsCase', null, global); +goog.exportSymbol('proto.models.proto.cofd.CoreFields', null, global); +goog.exportSymbol('proto.models.proto.cofd.MageFields', 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.models.proto.cofd.CoreFields = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.CoreFields, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CoreFields.displayName = 'proto.models.proto.cofd.CoreFields'; +} +/** + * 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.models.proto.cofd.MageFields = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.MageFields, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.MageFields.displayName = 'proto.models.proto.cofd.MageFields'; +} +/** + * 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.models.proto.cofd.ChangelingFields = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.ChangelingFields, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.ChangelingFields.displayName = 'proto.models.proto.cofd.ChangelingFields'; +} +/** + * 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.models.proto.cofd.CofdSheet = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.CofdSheet.repeatedFields_, proto.models.proto.cofd.CofdSheet.oneofGroups_); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.displayName = 'proto.models.proto.cofd.CofdSheet'; +} +/** + * 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.models.proto.cofd.CofdSheet.Merit = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet.Merit, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.Merit.displayName = 'proto.models.proto.cofd.CofdSheet.Merit'; +} +/** + * 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.models.proto.cofd.CofdSheet.Condition = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet.Condition, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.Condition.displayName = 'proto.models.proto.cofd.CofdSheet.Condition'; +} +/** + * 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.models.proto.cofd.CofdSheet.Skill = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.CofdSheet.Skill.repeatedFields_, null); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet.Skill, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.Skill.displayName = 'proto.models.proto.cofd.CofdSheet.Skill'; +} +/** + * 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.models.proto.cofd.CofdSheet.Item = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet.Item, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.Item.displayName = 'proto.models.proto.cofd.CofdSheet.Item'; +} +/** + * 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.models.proto.cofd.CofdSheet.Attack = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.models.proto.cofd.CofdSheet.Attack, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.models.proto.cofd.CofdSheet.Attack.displayName = 'proto.models.proto.cofd.CofdSheet.Attack'; +} + + + +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.models.proto.cofd.CoreFields.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CoreFields.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.models.proto.cofd.CoreFields} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CoreFields.toObject = function(includeInstance, msg) { + var f, obj = { + integrity: 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.models.proto.cofd.CoreFields} + */ +proto.models.proto.cofd.CoreFields.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CoreFields; + return proto.models.proto.cofd.CoreFields.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CoreFields} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CoreFields} + */ +proto.models.proto.cofd.CoreFields.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setIntegrity(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CoreFields.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CoreFields.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CoreFields} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CoreFields.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIntegrity(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } +}; + + +/** + * optional int32 integrity = 1; + * @return {number} + */ +proto.models.proto.cofd.CoreFields.prototype.getIntegrity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CoreFields} returns this + */ +proto.models.proto.cofd.CoreFields.prototype.setIntegrity = function(value) { + return jspb.Message.setProto3IntField(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} + */ +proto.models.proto.cofd.MageFields.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.MageFields.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.models.proto.cofd.MageFields} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.MageFields.toObject = function(includeInstance, msg) { + var f, obj = { + widsom: 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.models.proto.cofd.MageFields} + */ +proto.models.proto.cofd.MageFields.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.MageFields; + return proto.models.proto.cofd.MageFields.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.MageFields} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.MageFields} + */ +proto.models.proto.cofd.MageFields.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setWidsom(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.MageFields.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.MageFields.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.MageFields} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.MageFields.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getWidsom(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } +}; + + +/** + * optional int32 widsom = 1; + * @return {number} + */ +proto.models.proto.cofd.MageFields.prototype.getWidsom = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.MageFields} returns this + */ +proto.models.proto.cofd.MageFields.prototype.setWidsom = function(value) { + return jspb.Message.setProto3IntField(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} + */ +proto.models.proto.cofd.ChangelingFields.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.ChangelingFields.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.models.proto.cofd.ChangelingFields} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.ChangelingFields.toObject = function(includeInstance, msg) { + var f, obj = { + clarity: 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.models.proto.cofd.ChangelingFields} + */ +proto.models.proto.cofd.ChangelingFields.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.ChangelingFields; + return proto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.ChangelingFields} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.ChangelingFields} + */ +proto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setClarity(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.ChangelingFields.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.ChangelingFields} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getClarity(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } +}; + + +/** + * optional int32 clarity = 1; + * @return {number} + */ +proto.models.proto.cofd.ChangelingFields.prototype.getClarity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.ChangelingFields} returns this + */ +proto.models.proto.cofd.ChangelingFields.prototype.setClarity = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.models.proto.cofd.CofdSheet.repeatedFields_ = [15,19,25,26]; + +/** + * 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.models.proto.cofd.CofdSheet.oneofGroups_ = [[28,29,30]]; + +/** + * @enum {number} + */ +proto.models.proto.cofd.CofdSheet.SystemFieldsCase = { + SYSTEM_FIELDS_NOT_SET: 0, + CORE: 28, + MAGE: 29, + CHANGELING: 30 +}; + +/** + * @return {proto.models.proto.cofd.CofdSheet.SystemFieldsCase} + */ +proto.models.proto.cofd.CofdSheet.prototype.getSystemFieldsCase = function() { + return /** @type {proto.models.proto.cofd.CofdSheet.SystemFieldsCase} */(jspb.Message.computeOneofCase(this, proto.models.proto.cofd.CofdSheet.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.models.proto.cofd.CofdSheet.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.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.models.proto.cofd.CofdSheet} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + player: jspb.Message.getFieldWithDefault(msg, 2, ""), + campaign: jspb.Message.getFieldWithDefault(msg, 3, ""), + description: jspb.Message.getFieldWithDefault(msg, 4, ""), + strength: jspb.Message.getFieldWithDefault(msg, 6, 0), + dexterity: jspb.Message.getFieldWithDefault(msg, 7, 0), + stamina: jspb.Message.getFieldWithDefault(msg, 8, 0), + intelligence: jspb.Message.getFieldWithDefault(msg, 9, 0), + wits: jspb.Message.getFieldWithDefault(msg, 10, 0), + resolve: jspb.Message.getFieldWithDefault(msg, 11, 0), + presence: jspb.Message.getFieldWithDefault(msg, 12, 0), + manipulation: jspb.Message.getFieldWithDefault(msg, 13, 0), + composure: jspb.Message.getFieldWithDefault(msg, 14, 0), + physicalSkillsMap: (f = msg.getPhysicalSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [], + mentalSkillsMap: (f = msg.getMentalSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [], + socialSkillsMap: (f = msg.getSocialSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [], + meritsList: jspb.Message.toObjectList(msg.getMeritsList(), + proto.models.proto.cofd.CofdSheet.Merit.toObject, includeInstance), + conditionsList: jspb.Message.toObjectList(msg.getConditionsList(), + proto.models.proto.cofd.CofdSheet.Condition.toObject, includeInstance), + size: jspb.Message.getFieldWithDefault(msg, 20, 0), + health: jspb.Message.getFieldWithDefault(msg, 21, 0), + willpower: jspb.Message.getFieldWithDefault(msg, 22, 0), + experiencePoints: jspb.Message.getFieldWithDefault(msg, 23, 0), + beats: jspb.Message.getFieldWithDefault(msg, 24, 0), + itemsList: jspb.Message.toObjectList(msg.getItemsList(), + proto.models.proto.cofd.CofdSheet.Item.toObject, includeInstance), + attacksList: jspb.Message.toObjectList(msg.getAttacksList(), + proto.models.proto.cofd.CofdSheet.Attack.toObject, includeInstance), + otherDataMap: (f = msg.getOtherDataMap()) ? f.toObject(includeInstance, undefined) : [], + core: (f = msg.getCore()) && proto.models.proto.cofd.CoreFields.toObject(includeInstance, f), + mage: (f = msg.getMage()) && proto.models.proto.cofd.MageFields.toObject(includeInstance, f), + changeling: (f = msg.getChangeling()) && proto.models.proto.cofd.ChangelingFields.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.models.proto.cofd.CofdSheet} + */ +proto.models.proto.cofd.CofdSheet.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet; + return proto.models.proto.cofd.CofdSheet.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet} + */ +proto.models.proto.cofd.CofdSheet.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.setPlayer(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setCampaign(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setDescription(value); + break; + case 6: + var value = /** @type {number} */ (reader.readInt32()); + msg.setStrength(value); + break; + case 7: + var value = /** @type {number} */ (reader.readInt32()); + msg.setDexterity(value); + break; + case 8: + var value = /** @type {number} */ (reader.readInt32()); + msg.setStamina(value); + break; + case 9: + var value = /** @type {number} */ (reader.readInt32()); + msg.setIntelligence(value); + break; + case 10: + var value = /** @type {number} */ (reader.readInt32()); + msg.setWits(value); + break; + case 11: + var value = /** @type {number} */ (reader.readInt32()); + msg.setResolve(value); + break; + case 12: + var value = /** @type {number} */ (reader.readInt32()); + msg.setPresence(value); + break; + case 13: + var value = /** @type {number} */ (reader.readInt32()); + msg.setManipulation(value); + break; + case 14: + var value = /** @type {number} */ (reader.readInt32()); + msg.setComposure(value); + break; + case 16: + var value = msg.getPhysicalSkillsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, "", new proto.models.proto.cofd.CofdSheet.Skill()); + }); + break; + case 17: + var value = msg.getMentalSkillsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, "", new proto.models.proto.cofd.CofdSheet.Skill()); + }); + break; + case 18: + var value = msg.getSocialSkillsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, "", new proto.models.proto.cofd.CofdSheet.Skill()); + }); + break; + case 15: + var value = new proto.models.proto.cofd.CofdSheet.Merit; + reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader); + msg.addMerits(value); + break; + case 19: + var value = new proto.models.proto.cofd.CofdSheet.Condition; + reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Condition.deserializeBinaryFromReader); + msg.addConditions(value); + break; + case 20: + var value = /** @type {number} */ (reader.readInt32()); + msg.setSize(value); + break; + case 21: + var value = /** @type {number} */ (reader.readInt32()); + msg.setHealth(value); + break; + case 22: + var value = /** @type {number} */ (reader.readInt32()); + msg.setWillpower(value); + break; + case 23: + var value = /** @type {number} */ (reader.readInt32()); + msg.setExperiencePoints(value); + break; + case 24: + var value = /** @type {number} */ (reader.readInt32()); + msg.setBeats(value); + break; + case 25: + var value = new proto.models.proto.cofd.CofdSheet.Item; + reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Item.deserializeBinaryFromReader); + msg.addItems(value); + break; + case 26: + var value = new proto.models.proto.cofd.CofdSheet.Attack; + reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Attack.deserializeBinaryFromReader); + msg.addAttacks(value); + break; + case 27: + var value = msg.getOtherDataMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, "", ""); + }); + break; + case 28: + var value = new proto.models.proto.cofd.CoreFields; + reader.readMessage(value,proto.models.proto.cofd.CoreFields.deserializeBinaryFromReader); + msg.setCore(value); + break; + case 29: + var value = new proto.models.proto.cofd.MageFields; + reader.readMessage(value,proto.models.proto.cofd.MageFields.deserializeBinaryFromReader); + msg.setMage(value); + break; + case 30: + var value = new proto.models.proto.cofd.ChangelingFields; + reader.readMessage(value,proto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader); + msg.setChangeling(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getPlayer(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getCampaign(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getDescription(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getStrength(); + if (f !== 0) { + writer.writeInt32( + 6, + f + ); + } + f = message.getDexterity(); + if (f !== 0) { + writer.writeInt32( + 7, + f + ); + } + f = message.getStamina(); + if (f !== 0) { + writer.writeInt32( + 8, + f + ); + } + f = message.getIntelligence(); + if (f !== 0) { + writer.writeInt32( + 9, + f + ); + } + f = message.getWits(); + if (f !== 0) { + writer.writeInt32( + 10, + f + ); + } + f = message.getResolve(); + if (f !== 0) { + writer.writeInt32( + 11, + f + ); + } + f = message.getPresence(); + if (f !== 0) { + writer.writeInt32( + 12, + f + ); + } + f = message.getManipulation(); + if (f !== 0) { + writer.writeInt32( + 13, + f + ); + } + f = message.getComposure(); + if (f !== 0) { + writer.writeInt32( + 14, + f + ); + } + f = message.getPhysicalSkillsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(16, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter); + } + f = message.getMentalSkillsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(17, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter); + } + f = message.getSocialSkillsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(18, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter); + } + f = message.getMeritsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 15, + f, + proto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter + ); + } + f = message.getConditionsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 19, + f, + proto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter + ); + } + f = message.getSize(); + if (f !== 0) { + writer.writeInt32( + 20, + f + ); + } + f = message.getHealth(); + if (f !== 0) { + writer.writeInt32( + 21, + f + ); + } + f = message.getWillpower(); + if (f !== 0) { + writer.writeInt32( + 22, + f + ); + } + f = message.getExperiencePoints(); + if (f !== 0) { + writer.writeInt32( + 23, + f + ); + } + f = message.getBeats(); + if (f !== 0) { + writer.writeInt32( + 24, + f + ); + } + f = message.getItemsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 25, + f, + proto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter + ); + } + f = message.getAttacksList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 26, + f, + proto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter + ); + } + f = message.getOtherDataMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(27, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); + } + f = message.getCore(); + if (f != null) { + writer.writeMessage( + 28, + f, + proto.models.proto.cofd.CoreFields.serializeBinaryToWriter + ); + } + f = message.getMage(); + if (f != null) { + writer.writeMessage( + 29, + f, + proto.models.proto.cofd.MageFields.serializeBinaryToWriter + ); + } + f = message.getChangeling(); + if (f != null) { + writer.writeMessage( + 30, + f, + proto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter + ); + } +}; + + + + + +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.models.proto.cofd.CofdSheet.Merit.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.Merit.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.models.proto.cofd.CofdSheet.Merit} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Merit.toObject = function(includeInstance, msg) { + var f, obj = { + dots: jspb.Message.getFieldWithDefault(msg, 1, 0), + name: 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.models.proto.cofd.CofdSheet.Merit} + */ +proto.models.proto.cofd.CofdSheet.Merit.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet.Merit; + return proto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet.Merit} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet.Merit} + */ +proto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setDots(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.Merit.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet.Merit} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDots(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional int32 dots = 1; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Merit.prototype.getDots = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Merit} returns this + */ +proto.models.proto.cofd.CofdSheet.Merit.prototype.setDots = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Merit.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Merit} returns this + */ +proto.models.proto.cofd.CofdSheet.Merit.prototype.setName = 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.models.proto.cofd.CofdSheet.Condition.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.Condition.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.models.proto.cofd.CofdSheet.Condition} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Condition.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.models.proto.cofd.CofdSheet.Condition} + */ +proto.models.proto.cofd.CofdSheet.Condition.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet.Condition; + return proto.models.proto.cofd.CofdSheet.Condition.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet.Condition} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet.Condition} + */ +proto.models.proto.cofd.CofdSheet.Condition.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; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.Condition.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet.Condition} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Condition.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Condition} returns this + */ +proto.models.proto.cofd.CofdSheet.Condition.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.models.proto.cofd.CofdSheet.Skill.repeatedFields_ = [4]; + + + +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.models.proto.cofd.CofdSheet.Skill.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.Skill.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.models.proto.cofd.CofdSheet.Skill} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Skill.toObject = function(includeInstance, msg) { + var f, obj = { + dots: jspb.Message.getFieldWithDefault(msg, 1, 0), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + untrainedPenalty: jspb.Message.getFieldWithDefault(msg, 3, 0), + specializationsList: (f = jspb.Message.getRepeatedField(msg, 4)) == 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.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.CofdSheet.Skill.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet.Skill; + return proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet.Skill} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet.Skill} + */ +proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt32()); + msg.setDots(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 3: + var value = /** @type {number} */ (reader.readSint32()); + msg.setUntrainedPenalty(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.addSpecializations(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet.Skill} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDots(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getUntrainedPenalty(); + if (f !== 0) { + writer.writeSint32( + 3, + f + ); + } + f = message.getSpecializationsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 4, + f + ); + } +}; + + +/** + * optional int32 dots = 1; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.getDots = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.setDots = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional sint32 untrained_penalty = 3; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.getUntrainedPenalty = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.setUntrainedPenalty = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * repeated string specializations = 4; + * @return {!Array} + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.getSpecializationsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 4)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.setSpecializationsList = function(value) { + return jspb.Message.setField(this, 4, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.addSpecializations = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 4, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this + */ +proto.models.proto.cofd.CofdSheet.Skill.prototype.clearSpecializationsList = function() { + return this.setSpecializationsList([]); +}; + + + + + +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.models.proto.cofd.CofdSheet.Item.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.Item.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.models.proto.cofd.CofdSheet.Item} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Item.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + description: jspb.Message.getFieldWithDefault(msg, 2, ""), + rules: jspb.Message.getFieldWithDefault(msg, 3, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.models.proto.cofd.CofdSheet.Item} + */ +proto.models.proto.cofd.CofdSheet.Item.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet.Item; + return proto.models.proto.cofd.CofdSheet.Item.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet.Item} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet.Item} + */ +proto.models.proto.cofd.CofdSheet.Item.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.setDescription(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setRules(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet.Item} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getDescription(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getRules(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string description = 2; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.getDescription = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.setDescription = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string rules = 3; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.getRules = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this + */ +proto.models.proto.cofd.CofdSheet.Item.prototype.setRules = function(value) { + return jspb.Message.setProto3StringField(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} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.toObject = function(opt_includeInstance) { + return proto.models.proto.cofd.CofdSheet.Attack.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.models.proto.cofd.CofdSheet.Attack} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Attack.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + dicePool: jspb.Message.getFieldWithDefault(msg, 2, 0), + damage: jspb.Message.getFieldWithDefault(msg, 3, 0), + range: jspb.Message.getFieldWithDefault(msg, 4, 0), + initiativeModifier: jspb.Message.getFieldWithDefault(msg, 5, 0), + size: jspb.Message.getFieldWithDefault(msg, 6, 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.models.proto.cofd.CofdSheet.Attack} + */ +proto.models.proto.cofd.CofdSheet.Attack.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.models.proto.cofd.CofdSheet.Attack; + return proto.models.proto.cofd.CofdSheet.Attack.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.models.proto.cofd.CofdSheet.Attack} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.models.proto.cofd.CofdSheet.Attack} + */ +proto.models.proto.cofd.CofdSheet.Attack.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 {number} */ (reader.readInt32()); + msg.setDicePool(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setDamage(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setRange(value); + break; + case 5: + var value = /** @type {number} */ (reader.readSint32()); + msg.setInitiativeModifier(value); + break; + case 6: + var value = /** @type {number} */ (reader.readInt32()); + msg.setSize(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.models.proto.cofd.CofdSheet.Attack} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getDicePool(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getDamage(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getRange(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } + f = message.getInitiativeModifier(); + if (f !== 0) { + writer.writeSint32( + 5, + f + ); + } + f = message.getSize(); + if (f !== 0) { + writer.writeInt32( + 6, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional int32 dice_pool = 2; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getDicePool = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setDicePool = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 damage = 3; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getDamage = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setDamage = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional int32 range = 4; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getRange = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setRange = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional sint32 initiative_modifier = 5; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getInitiativeModifier = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setInitiativeModifier = function(value) { + return jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional int32 size = 6; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.getSize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this + */ +proto.models.proto.cofd.CofdSheet.Attack.prototype.setSize = function(value) { + return jspb.Message.setProto3IntField(this, 6, value); +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string player = 2; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.prototype.getPlayer = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setPlayer = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string campaign = 3; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.prototype.getCampaign = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setCampaign = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string description = 4; + * @return {string} + */ +proto.models.proto.cofd.CofdSheet.prototype.getDescription = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setDescription = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional int32 strength = 6; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getStrength = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setStrength = function(value) { + return jspb.Message.setProto3IntField(this, 6, value); +}; + + +/** + * optional int32 dexterity = 7; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getDexterity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setDexterity = function(value) { + return jspb.Message.setProto3IntField(this, 7, value); +}; + + +/** + * optional int32 stamina = 8; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getStamina = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setStamina = function(value) { + return jspb.Message.setProto3IntField(this, 8, value); +}; + + +/** + * optional int32 intelligence = 9; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getIntelligence = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setIntelligence = function(value) { + return jspb.Message.setProto3IntField(this, 9, value); +}; + + +/** + * optional int32 wits = 10; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getWits = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 10, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setWits = function(value) { + return jspb.Message.setProto3IntField(this, 10, value); +}; + + +/** + * optional int32 resolve = 11; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getResolve = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 11, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setResolve = function(value) { + return jspb.Message.setProto3IntField(this, 11, value); +}; + + +/** + * optional int32 presence = 12; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getPresence = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 12, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setPresence = function(value) { + return jspb.Message.setProto3IntField(this, 12, value); +}; + + +/** + * optional int32 manipulation = 13; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getManipulation = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 13, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setManipulation = function(value) { + return jspb.Message.setProto3IntField(this, 13, value); +}; + + +/** + * optional int32 composure = 14; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getComposure = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 14, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setComposure = function(value) { + return jspb.Message.setProto3IntField(this, 14, value); +}; + + +/** + * map physical_skills = 16; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.models.proto.cofd.CofdSheet.prototype.getPhysicalSkillsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 16, opt_noLazyCreate, + proto.models.proto.cofd.CofdSheet.Skill)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearPhysicalSkillsMap = function() { + this.getPhysicalSkillsMap().clear(); + return this;}; + + +/** + * map mental_skills = 17; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.models.proto.cofd.CofdSheet.prototype.getMentalSkillsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 17, opt_noLazyCreate, + proto.models.proto.cofd.CofdSheet.Skill)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearMentalSkillsMap = function() { + this.getMentalSkillsMap().clear(); + return this;}; + + +/** + * map social_skills = 18; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.models.proto.cofd.CofdSheet.prototype.getSocialSkillsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 18, opt_noLazyCreate, + proto.models.proto.cofd.CofdSheet.Skill)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearSocialSkillsMap = function() { + this.getSocialSkillsMap().clear(); + return this;}; + + +/** + * repeated Merit merits = 15; + * @return {!Array} + */ +proto.models.proto.cofd.CofdSheet.prototype.getMeritsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Merit, 15)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setMeritsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 15, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Merit=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Merit} + */ +proto.models.proto.cofd.CofdSheet.prototype.addMerits = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 15, opt_value, proto.models.proto.cofd.CofdSheet.Merit, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearMeritsList = function() { + return this.setMeritsList([]); +}; + + +/** + * repeated Condition conditions = 19; + * @return {!Array} + */ +proto.models.proto.cofd.CofdSheet.prototype.getConditionsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Condition, 19)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setConditionsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 19, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Condition=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Condition} + */ +proto.models.proto.cofd.CofdSheet.prototype.addConditions = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 19, opt_value, proto.models.proto.cofd.CofdSheet.Condition, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearConditionsList = function() { + return this.setConditionsList([]); +}; + + +/** + * optional int32 size = 20; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getSize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 20, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setSize = function(value) { + return jspb.Message.setProto3IntField(this, 20, value); +}; + + +/** + * optional int32 health = 21; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getHealth = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 21, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setHealth = function(value) { + return jspb.Message.setProto3IntField(this, 21, value); +}; + + +/** + * optional int32 willpower = 22; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getWillpower = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 22, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setWillpower = function(value) { + return jspb.Message.setProto3IntField(this, 22, value); +}; + + +/** + * optional int32 experience_points = 23; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getExperiencePoints = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 23, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setExperiencePoints = function(value) { + return jspb.Message.setProto3IntField(this, 23, value); +}; + + +/** + * optional int32 beats = 24; + * @return {number} + */ +proto.models.proto.cofd.CofdSheet.prototype.getBeats = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 24, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.setBeats = function(value) { + return jspb.Message.setProto3IntField(this, 24, value); +}; + + +/** + * repeated Item items = 25; + * @return {!Array} + */ +proto.models.proto.cofd.CofdSheet.prototype.getItemsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Item, 25)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setItemsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 25, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Item=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Item} + */ +proto.models.proto.cofd.CofdSheet.prototype.addItems = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 25, opt_value, proto.models.proto.cofd.CofdSheet.Item, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearItemsList = function() { + return this.setItemsList([]); +}; + + +/** + * repeated Attack attacks = 26; + * @return {!Array} + */ +proto.models.proto.cofd.CofdSheet.prototype.getAttacksList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Attack, 26)); +}; + + +/** + * @param {!Array} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setAttacksList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 26, value); +}; + + +/** + * @param {!proto.models.proto.cofd.CofdSheet.Attack=} opt_value + * @param {number=} opt_index + * @return {!proto.models.proto.cofd.CofdSheet.Attack} + */ +proto.models.proto.cofd.CofdSheet.prototype.addAttacks = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 26, opt_value, proto.models.proto.cofd.CofdSheet.Attack, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearAttacksList = function() { + return this.setAttacksList([]); +}; + + +/** + * map other_data = 27; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.models.proto.cofd.CofdSheet.prototype.getOtherDataMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 27, opt_noLazyCreate, + null)); +}; + + +/** + * Clears values from the map. The map will be non-null. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearOtherDataMap = function() { + this.getOtherDataMap().clear(); + return this;}; + + +/** + * optional CoreFields core = 28; + * @return {?proto.models.proto.cofd.CoreFields} + */ +proto.models.proto.cofd.CofdSheet.prototype.getCore = function() { + return /** @type{?proto.models.proto.cofd.CoreFields} */ ( + jspb.Message.getWrapperField(this, proto.models.proto.cofd.CoreFields, 28)); +}; + + +/** + * @param {?proto.models.proto.cofd.CoreFields|undefined} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setCore = function(value) { + return jspb.Message.setOneofWrapperField(this, 28, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearCore = function() { + return this.setCore(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.models.proto.cofd.CofdSheet.prototype.hasCore = function() { + return jspb.Message.getField(this, 28) != null; +}; + + +/** + * optional MageFields mage = 29; + * @return {?proto.models.proto.cofd.MageFields} + */ +proto.models.proto.cofd.CofdSheet.prototype.getMage = function() { + return /** @type{?proto.models.proto.cofd.MageFields} */ ( + jspb.Message.getWrapperField(this, proto.models.proto.cofd.MageFields, 29)); +}; + + +/** + * @param {?proto.models.proto.cofd.MageFields|undefined} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setMage = function(value) { + return jspb.Message.setOneofWrapperField(this, 29, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearMage = function() { + return this.setMage(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.models.proto.cofd.CofdSheet.prototype.hasMage = function() { + return jspb.Message.getField(this, 29) != null; +}; + + +/** + * optional ChangelingFields changeling = 30; + * @return {?proto.models.proto.cofd.ChangelingFields} + */ +proto.models.proto.cofd.CofdSheet.prototype.getChangeling = function() { + return /** @type{?proto.models.proto.cofd.ChangelingFields} */ ( + jspb.Message.getWrapperField(this, proto.models.proto.cofd.ChangelingFields, 30)); +}; + + +/** + * @param {?proto.models.proto.cofd.ChangelingFields|undefined} value + * @return {!proto.models.proto.cofd.CofdSheet} returns this +*/ +proto.models.proto.cofd.CofdSheet.prototype.setChangeling = function(value) { + return jspb.Message.setOneofWrapperField(this, 30, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.models.proto.cofd.CofdSheet} returns this + */ +proto.models.proto.cofd.CofdSheet.prototype.clearChangeling = function() { + return this.setChangeling(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.models.proto.cofd.CofdSheet.prototype.hasChangeling = function() { + return jspb.Message.getField(this, 30) != null; +}; + + +goog.object.extend(exports, proto.models.proto.cofd); + + +/***/ }) + +}]); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///./_proto/cofd_api_pb.js","webpack:///./_proto/cofd_pb.js"],"names":[],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA;;AAEA,WAAW,mBAAO,CAAC,8EAAiB;AACpC;AACA;;AAEA,cAAc,mBAAO,CAAC,yCAAc;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,uCAAuC;AAClD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,uCAAuC;AAClD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,uCAAuC;AAClD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,wCAAwC;AACnD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wCAAwC;AACnD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wCAAwC;AACnD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,oDAAoD;AAC/D,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oDAAoD;AAC/D,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oDAAoD;AAC/D,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oDAAoD;AAChE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oDAAoD;AAChE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oDAAoD;AAChE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oDAAoD;AAChE;AACA;AACA;AACA;;;;AAIA;AACA;AACA,aAAa;AACb;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,oCAAoC;AAC/C,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,iDAAiD;AACpE;AACA;;;AAGA;AACA,WAAW,iDAAiD;AAC5D,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;AAGA;AACA,WAAW,0CAA0C;AACrD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,iDAAiD;AACpE;AACA;;;AAGA;AACA,WAAW,iDAAiD;AAC5D,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;AAGA;AACA,WAAW,0CAA0C;AACrD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,iDAAiD;AACpE;AACA;;;AAGA;AACA,WAAW,iDAAiD;AAC5D,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;AAGA;AACA,WAAW,0CAA0C;AACrD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,yCAAyC;AACpD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,yCAAyC;AAC5D;AACA;;;AAGA;AACA,WAAW,mDAAmD;AAC9D,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,qDAAqD;AAChE,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,qDAAqD;AAChE,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,qDAAqD;AAChE,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,qDAAqD;AACjE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,qDAAqD;AACjE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,qDAAqD;AACjE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,qDAAqD;AACjE;AACA;AACA;AACA;;;;AAIA;AACA;AACA,aAAa;AACb;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,wDAAwD;AACnE,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wDAAwD;AACnE,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wDAAwD;AACnE,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wDAAwD;AACpE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,eAAe;AACnC;;;AAGA;AACA,WAAW,eAAe;AAC1B,YAAY,wDAAwD;AACpE;AACA;AACA;AACA;;;AAGA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,YAAY,wDAAwD;AACpE;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,wDAAwD;AACpE;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,uCAAuC;AAClD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,uCAAuC;AAClD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,uCAAuC;AAClD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,uCAAuC;AACnD;AACA;AACA;AACA;;;AAGA;;;;;;;;;;;ACj+DA;AACA;AACA;AACA;AACA,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA;;AAEA,WAAW,mBAAO,CAAC,8EAAiB;AACpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,oCAAoC;AAC/C,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,oCAAoC;AAC/C,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,oCAAoC;AAC/C,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,oCAAoC;AAChD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,0CAA0C;AACrD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,0CAA0C;AACrD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,0CAA0C;AACrD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;;AAIA;AACA;AACA,aAAa;AACb;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;;AAEA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,mDAAmD;AACvE;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,mCAAmC;AAC9C,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,mCAAmC;AAC9C,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,mCAAmC;AAC9C,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,yCAAyC;AACpD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,6CAA6C;AACxD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,6CAA6C;AACxD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,6CAA6C;AACxD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,6CAA6C;AACzD;AACA;AACA;AACA;;;;AAIA;AACA;AACA,aAAa;AACb;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,yCAAyC;AACpD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,yCAAyC;AACpD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,eAAe;AACnC;;;AAGA;AACA,WAAW,eAAe;AAC1B,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,yCAAyC;AACrD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,wCAAwC;AACnD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wCAAwC;AACnD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,wCAAwC;AACnD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,wCAAwC;AACpD;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA,0BAA0B,cAAc;AACxC,WAAW,kBAAkB;AAC7B;AACA;AACA,WAAW,0CAA0C;AACrD,YAAY;AACZ,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,gBAAgB;AAC3B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,0CAA0C;AACrD,WAAW,mBAAmB;AAC9B,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA,6BAA6B,OAAO;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,WAAW,0CAA0C;AACrD,WAAW,mBAAmB;AAC9B,cAAc,qBAAqB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,0CAA0C;AACtD;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,SAAS;AACpB;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,2DAA2D;AAC/E;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,SAAS;AACpB;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,2DAA2D;AAC/E;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,SAAS;AACpB;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,2DAA2D;AAC/E;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,iDAAiD;AACpE;AACA;;;AAGA;AACA,WAAW,iDAAiD;AAC5D,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA,WAAW,0CAA0C;AACrD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,qDAAqD;AACxE;AACA;;;AAGA;AACA,WAAW,qDAAqD;AAChE,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA,WAAW,8CAA8C;AACzD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,OAAO;AAC3B;;;AAGA;AACA,WAAW,OAAO;AAClB,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,gDAAgD;AACnE;AACA;;;AAGA;AACA,WAAW,gDAAgD;AAC3D,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA,WAAW,yCAAyC;AACpD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,kDAAkD;AACrE;AACA;;;AAGA;AACA,WAAW,kDAAkD;AAC7D,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA,WAAW,2CAA2C;AACtD,WAAW,QAAQ;AACnB,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,WAAW,SAAS;AACpB;AACA,YAAY;AACZ;AACA;AACA,oBAAoB,yBAAyB;AAC7C;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,oCAAoC;AACvD;AACA;;;AAGA;AACA,WAAW,8CAA8C;AACzD,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,oCAAoC;AACvD;AACA;;;AAGA;AACA,WAAW,8CAA8C;AACzD,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA,mBAAmB,0CAA0C;AAC7D;AACA;;;AAGA;AACA,WAAW,oDAAoD;AAC/D,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;;;AAGA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;;AAGA","file":"_proto_cofd_api_pb_js.bundle.js","sourcesContent":["// source: cofd_api.proto\n/**\n * @fileoverview\n * @enhanceable\n * @suppress {messageConventions} JS Compiler reports an error if a variable or\n *     field starts with 'MSG_' and isn't a translatable message.\n * @public\n */\n// GENERATED CODE -- DO NOT EDIT!\n/* eslint-disable */\n// @ts-nocheck\n\nvar jspb = require('google-protobuf');\nvar goog = jspb;\nvar global = Function('return this')();\n\nvar cofd_pb = require('./cofd_pb.js');\ngoog.object.extend(proto, cofd_pb);\ngoog.exportSymbol('proto.models.proto.cofd.api.Attributes', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.BasicInfo', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.Condition', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.SkillSpecializationsUpdate', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.SkillUpdate', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.Skills', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.UpdateAttributeRequest', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.api.UpdateSkillValueRequest', null, global);\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.BasicInfo = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.BasicInfo, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.BasicInfo.displayName = 'proto.models.proto.cofd.api.BasicInfo';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.Attributes = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.Attributes, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.Attributes.displayName = 'proto.models.proto.cofd.api.Attributes';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.UpdateAttributeRequest, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.UpdateAttributeRequest.displayName = 'proto.models.proto.cofd.api.UpdateAttributeRequest';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.Skills = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.api.Skills.repeatedFields_, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.Skills, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.Skills.displayName = 'proto.models.proto.cofd.api.Skills';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.SkillUpdate = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.SkillUpdate, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.SkillUpdate.displayName = 'proto.models.proto.cofd.api.SkillUpdate';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.UpdateSkillValueRequest, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.UpdateSkillValueRequest.displayName = 'proto.models.proto.cofd.api.UpdateSkillValueRequest';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.api.SkillSpecializationsUpdate.repeatedFields_, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.SkillSpecializationsUpdate, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.SkillSpecializationsUpdate.displayName = 'proto.models.proto.cofd.api.SkillSpecializationsUpdate';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.api.Condition = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.api.Condition, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.api.Condition.displayName = 'proto.models.proto.cofd.api.Condition';\n}\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.BasicInfo.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.BasicInfo} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.BasicInfo.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    gender: jspb.Message.getFieldWithDefault(msg, 2, \"\"),\n    concept: jspb.Message.getFieldWithDefault(msg, 3, \"\"),\n    chronicle: jspb.Message.getFieldWithDefault(msg, 4, \"\"),\n    age: jspb.Message.getFieldWithDefault(msg, 5, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.BasicInfo}\n */\nproto.models.proto.cofd.api.BasicInfo.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.BasicInfo;\n  return proto.models.proto.cofd.api.BasicInfo.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.BasicInfo} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.BasicInfo}\n */\nproto.models.proto.cofd.api.BasicInfo.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setGender(value);\n      break;\n    case 3:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setConcept(value);\n      break;\n    case 4:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setChronicle(value);\n      break;\n    case 5:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setAge(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.BasicInfo.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.BasicInfo} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.BasicInfo.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getGender();\n  if (f.length > 0) {\n    writer.writeString(\n      2,\n      f\n    );\n  }\n  f = message.getConcept();\n  if (f.length > 0) {\n    writer.writeString(\n      3,\n      f\n    );\n  }\n  f = message.getChronicle();\n  if (f.length > 0) {\n    writer.writeString(\n      4,\n      f\n    );\n  }\n  f = message.getAge();\n  if (f !== 0) {\n    writer.writeInt32(\n      5,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.BasicInfo} returns this\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional string gender = 2;\n * @return {string}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.getGender = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.BasicInfo} returns this\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.setGender = function(value) {\n  return jspb.Message.setProto3StringField(this, 2, value);\n};\n\n\n/**\n * optional string concept = 3;\n * @return {string}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.getConcept = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.BasicInfo} returns this\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.setConcept = function(value) {\n  return jspb.Message.setProto3StringField(this, 3, value);\n};\n\n\n/**\n * optional string chronicle = 4;\n * @return {string}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.getChronicle = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.BasicInfo} returns this\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.setChronicle = function(value) {\n  return jspb.Message.setProto3StringField(this, 4, value);\n};\n\n\n/**\n * optional int32 age = 5;\n * @return {number}\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.getAge = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.BasicInfo} returns this\n */\nproto.models.proto.cofd.api.BasicInfo.prototype.setAge = function(value) {\n  return jspb.Message.setProto3IntField(this, 5, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.Attributes.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.Attributes.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.Attributes} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Attributes.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    strength: jspb.Message.getFieldWithDefault(msg, 1, 0),\n    dexterity: jspb.Message.getFieldWithDefault(msg, 2, 0),\n    stamina: jspb.Message.getFieldWithDefault(msg, 3, 0),\n    intelligence: jspb.Message.getFieldWithDefault(msg, 4, 0),\n    wits: jspb.Message.getFieldWithDefault(msg, 5, 0),\n    resolve: jspb.Message.getFieldWithDefault(msg, 6, 0),\n    presence: jspb.Message.getFieldWithDefault(msg, 7, 0),\n    manipulation: jspb.Message.getFieldWithDefault(msg, 8, 0),\n    composure: jspb.Message.getFieldWithDefault(msg, 9, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.Attributes}\n */\nproto.models.proto.cofd.api.Attributes.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.Attributes;\n  return proto.models.proto.cofd.api.Attributes.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.Attributes} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.Attributes}\n */\nproto.models.proto.cofd.api.Attributes.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setStrength(value);\n      break;\n    case 2:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDexterity(value);\n      break;\n    case 3:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setStamina(value);\n      break;\n    case 4:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setIntelligence(value);\n      break;\n    case 5:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setWits(value);\n      break;\n    case 6:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setResolve(value);\n      break;\n    case 7:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setPresence(value);\n      break;\n    case 8:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setManipulation(value);\n      break;\n    case 9:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setComposure(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.Attributes.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.Attributes.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.Attributes} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Attributes.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getStrength();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n  f = message.getDexterity();\n  if (f !== 0) {\n    writer.writeInt32(\n      2,\n      f\n    );\n  }\n  f = message.getStamina();\n  if (f !== 0) {\n    writer.writeInt32(\n      3,\n      f\n    );\n  }\n  f = message.getIntelligence();\n  if (f !== 0) {\n    writer.writeInt32(\n      4,\n      f\n    );\n  }\n  f = message.getWits();\n  if (f !== 0) {\n    writer.writeInt32(\n      5,\n      f\n    );\n  }\n  f = message.getResolve();\n  if (f !== 0) {\n    writer.writeInt32(\n      6,\n      f\n    );\n  }\n  f = message.getPresence();\n  if (f !== 0) {\n    writer.writeInt32(\n      7,\n      f\n    );\n  }\n  f = message.getManipulation();\n  if (f !== 0) {\n    writer.writeInt32(\n      8,\n      f\n    );\n  }\n  f = message.getComposure();\n  if (f !== 0) {\n    writer.writeInt32(\n      9,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 strength = 1;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getStrength = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setStrength = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n/**\n * optional int32 dexterity = 2;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getDexterity = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setDexterity = function(value) {\n  return jspb.Message.setProto3IntField(this, 2, value);\n};\n\n\n/**\n * optional int32 stamina = 3;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getStamina = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setStamina = function(value) {\n  return jspb.Message.setProto3IntField(this, 3, value);\n};\n\n\n/**\n * optional int32 intelligence = 4;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getIntelligence = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setIntelligence = function(value) {\n  return jspb.Message.setProto3IntField(this, 4, value);\n};\n\n\n/**\n * optional int32 wits = 5;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getWits = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setWits = function(value) {\n  return jspb.Message.setProto3IntField(this, 5, value);\n};\n\n\n/**\n * optional int32 resolve = 6;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getResolve = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setResolve = function(value) {\n  return jspb.Message.setProto3IntField(this, 6, value);\n};\n\n\n/**\n * optional int32 presence = 7;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getPresence = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setPresence = function(value) {\n  return jspb.Message.setProto3IntField(this, 7, value);\n};\n\n\n/**\n * optional int32 manipulation = 8;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getManipulation = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setManipulation = function(value) {\n  return jspb.Message.setProto3IntField(this, 8, value);\n};\n\n\n/**\n * optional int32 composure = 9;\n * @return {number}\n */\nproto.models.proto.cofd.api.Attributes.prototype.getComposure = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.Attributes} returns this\n */\nproto.models.proto.cofd.api.Attributes.prototype.setComposure = function(value) {\n  return jspb.Message.setProto3IntField(this, 9, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.UpdateAttributeRequest.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.UpdateAttributeRequest} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    characterUsername: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    characterId: jspb.Message.getFieldWithDefault(msg, 2, 0),\n    attributeName: jspb.Message.getFieldWithDefault(msg, 3, \"\"),\n    attributeValue: jspb.Message.getFieldWithDefault(msg, 4, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.UpdateAttributeRequest;\n  return proto.models.proto.cofd.api.UpdateAttributeRequest.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.UpdateAttributeRequest} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setCharacterUsername(value);\n      break;\n    case 2:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setCharacterId(value);\n      break;\n    case 3:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setAttributeName(value);\n      break;\n    case 4:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setAttributeValue(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.UpdateAttributeRequest.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.UpdateAttributeRequest} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getCharacterUsername();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getCharacterId();\n  if (f !== 0) {\n    writer.writeInt32(\n      2,\n      f\n    );\n  }\n  f = message.getAttributeName();\n  if (f.length > 0) {\n    writer.writeString(\n      3,\n      f\n    );\n  }\n  f = message.getAttributeValue();\n  if (f !== 0) {\n    writer.writeInt32(\n      4,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string character_username = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getCharacterUsername = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setCharacterUsername = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional int32 character_id = 2;\n * @return {number}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getCharacterId = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setCharacterId = function(value) {\n  return jspb.Message.setProto3IntField(this, 2, value);\n};\n\n\n/**\n * optional string attribute_name = 3;\n * @return {string}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getAttributeName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setAttributeName = function(value) {\n  return jspb.Message.setProto3StringField(this, 3, value);\n};\n\n\n/**\n * optional int32 attribute_value = 4;\n * @return {number}\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.getAttributeValue = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.UpdateAttributeRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateAttributeRequest.prototype.setAttributeValue = function(value) {\n  return jspb.Message.setProto3IntField(this, 4, value);\n};\n\n\n\n/**\n * List of repeated fields within this message type.\n * @private {!Array<number>}\n * @const\n */\nproto.models.proto.cofd.api.Skills.repeatedFields_ = [1,2,3];\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.Skills.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.Skills.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.Skills} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Skills.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    physicalSkillsList: jspb.Message.toObjectList(msg.getPhysicalSkillsList(),\n    cofd_pb.CofdSheet.Skill.toObject, includeInstance),\n    mentalSkillsList: jspb.Message.toObjectList(msg.getMentalSkillsList(),\n    cofd_pb.CofdSheet.Skill.toObject, includeInstance),\n    socialSkillsList: jspb.Message.toObjectList(msg.getSocialSkillsList(),\n    cofd_pb.CofdSheet.Skill.toObject, includeInstance)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.Skills}\n */\nproto.models.proto.cofd.api.Skills.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.Skills;\n  return proto.models.proto.cofd.api.Skills.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.Skills} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.Skills}\n */\nproto.models.proto.cofd.api.Skills.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = new cofd_pb.CofdSheet.Skill;\n      reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader);\n      msg.addPhysicalSkills(value);\n      break;\n    case 2:\n      var value = new cofd_pb.CofdSheet.Skill;\n      reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader);\n      msg.addMentalSkills(value);\n      break;\n    case 3:\n      var value = new cofd_pb.CofdSheet.Skill;\n      reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader);\n      msg.addSocialSkills(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.Skills.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.Skills.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.Skills} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Skills.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getPhysicalSkillsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      1,\n      f,\n      cofd_pb.CofdSheet.Skill.serializeBinaryToWriter\n    );\n  }\n  f = message.getMentalSkillsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      2,\n      f,\n      cofd_pb.CofdSheet.Skill.serializeBinaryToWriter\n    );\n  }\n  f = message.getSocialSkillsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      3,\n      f,\n      cofd_pb.CofdSheet.Skill.serializeBinaryToWriter\n    );\n  }\n};\n\n\n/**\n * repeated models.proto.cofd.CofdSheet.Skill physical_skills = 1;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.api.Skills.prototype.getPhysicalSkillsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n    jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 1));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Skill>} value\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n*/\nproto.models.proto.cofd.api.Skills.prototype.setPhysicalSkillsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 1, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.api.Skills.prototype.addPhysicalSkills = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n */\nproto.models.proto.cofd.api.Skills.prototype.clearPhysicalSkillsList = function() {\n  return this.setPhysicalSkillsList([]);\n};\n\n\n/**\n * repeated models.proto.cofd.CofdSheet.Skill mental_skills = 2;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.api.Skills.prototype.getMentalSkillsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n    jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 2));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Skill>} value\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n*/\nproto.models.proto.cofd.api.Skills.prototype.setMentalSkillsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 2, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.api.Skills.prototype.addMentalSkills = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n */\nproto.models.proto.cofd.api.Skills.prototype.clearMentalSkillsList = function() {\n  return this.setMentalSkillsList([]);\n};\n\n\n/**\n * repeated models.proto.cofd.CofdSheet.Skill social_skills = 3;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.api.Skills.prototype.getSocialSkillsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n    jspb.Message.getRepeatedWrapperField(this, cofd_pb.CofdSheet.Skill, 3));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Skill>} value\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n*/\nproto.models.proto.cofd.api.Skills.prototype.setSocialSkillsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 3, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Skill=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.api.Skills.prototype.addSocialSkills = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.models.proto.cofd.CofdSheet.Skill, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.api.Skills} returns this\n */\nproto.models.proto.cofd.api.Skills.prototype.clearSocialSkillsList = function() {\n  return this.setSocialSkillsList([]);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.SkillUpdate.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.SkillUpdate} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.SkillUpdate.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    skill: (f = msg.getSkill()) && cofd_pb.CofdSheet.Skill.toObject(includeInstance, f)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.SkillUpdate}\n */\nproto.models.proto.cofd.api.SkillUpdate.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.SkillUpdate;\n  return proto.models.proto.cofd.api.SkillUpdate.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.SkillUpdate} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.SkillUpdate}\n */\nproto.models.proto.cofd.api.SkillUpdate.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = new cofd_pb.CofdSheet.Skill;\n      reader.readMessage(value,cofd_pb.CofdSheet.Skill.deserializeBinaryFromReader);\n      msg.setSkill(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.SkillUpdate.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.SkillUpdate} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.SkillUpdate.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getSkill();\n  if (f != null) {\n    writer.writeMessage(\n      2,\n      f,\n      cofd_pb.CofdSheet.Skill.serializeBinaryToWriter\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional models.proto.cofd.CofdSheet.Skill skill = 2;\n * @return {?proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.getSkill = function() {\n  return /** @type{?proto.models.proto.cofd.CofdSheet.Skill} */ (\n    jspb.Message.getWrapperField(this, cofd_pb.CofdSheet.Skill, 2));\n};\n\n\n/**\n * @param {?proto.models.proto.cofd.CofdSheet.Skill|undefined} value\n * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this\n*/\nproto.models.proto.cofd.api.SkillUpdate.prototype.setSkill = function(value) {\n  return jspb.Message.setWrapperField(this, 2, value);\n};\n\n\n/**\n * Clears the message field making it undefined.\n * @return {!proto.models.proto.cofd.api.SkillUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.clearSkill = function() {\n  return this.setSkill(undefined);\n};\n\n\n/**\n * Returns whether this field is set.\n * @return {boolean}\n */\nproto.models.proto.cofd.api.SkillUpdate.prototype.hasSkill = function() {\n  return jspb.Message.getField(this, 2) != null;\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.UpdateSkillValueRequest.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.UpdateSkillValueRequest} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    characterUsername: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    characterId: jspb.Message.getFieldWithDefault(msg, 2, 0),\n    skillName: jspb.Message.getFieldWithDefault(msg, 3, \"\"),\n    skillValue: jspb.Message.getFieldWithDefault(msg, 4, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.UpdateSkillValueRequest;\n  return proto.models.proto.cofd.api.UpdateSkillValueRequest.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.UpdateSkillValueRequest} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setCharacterUsername(value);\n      break;\n    case 2:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setCharacterId(value);\n      break;\n    case 3:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setSkillName(value);\n      break;\n    case 4:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setSkillValue(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.UpdateSkillValueRequest.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.UpdateSkillValueRequest} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getCharacterUsername();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getCharacterId();\n  if (f !== 0) {\n    writer.writeInt32(\n      2,\n      f\n    );\n  }\n  f = message.getSkillName();\n  if (f.length > 0) {\n    writer.writeString(\n      3,\n      f\n    );\n  }\n  f = message.getSkillValue();\n  if (f !== 0) {\n    writer.writeInt32(\n      4,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string character_username = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getCharacterUsername = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setCharacterUsername = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional int32 character_id = 2;\n * @return {number}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getCharacterId = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setCharacterId = function(value) {\n  return jspb.Message.setProto3IntField(this, 2, value);\n};\n\n\n/**\n * optional string skill_name = 3;\n * @return {string}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getSkillName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setSkillName = function(value) {\n  return jspb.Message.setProto3StringField(this, 3, value);\n};\n\n\n/**\n * optional int32 skill_value = 4;\n * @return {number}\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.getSkillValue = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.api.UpdateSkillValueRequest} returns this\n */\nproto.models.proto.cofd.api.UpdateSkillValueRequest.prototype.setSkillValue = function(value) {\n  return jspb.Message.setProto3IntField(this, 4, value);\n};\n\n\n\n/**\n * List of repeated fields within this message type.\n * @private {!Array<number>}\n * @const\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.repeatedFields_ = [2];\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.SkillSpecializationsUpdate.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    specializationsList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.SkillSpecializationsUpdate;\n  return proto.models.proto.cofd.api.SkillSpecializationsUpdate.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.addSpecializations(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.SkillSpecializationsUpdate.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getSpecializationsList();\n  if (f.length > 0) {\n    writer.writeRepeatedString(\n      2,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * repeated string specializations = 2;\n * @return {!Array<string>}\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.getSpecializationsList = function() {\n  return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 2));\n};\n\n\n/**\n * @param {!Array<string>} value\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.setSpecializationsList = function(value) {\n  return jspb.Message.setField(this, 2, value || []);\n};\n\n\n/**\n * @param {string} value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.addSpecializations = function(value, opt_index) {\n  return jspb.Message.addToRepeatedField(this, 2, value, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.api.SkillSpecializationsUpdate} returns this\n */\nproto.models.proto.cofd.api.SkillSpecializationsUpdate.prototype.clearSpecializationsList = function() {\n  return this.setSpecializationsList([]);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.api.Condition.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.api.Condition.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.api.Condition} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Condition.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\")\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.api.Condition}\n */\nproto.models.proto.cofd.api.Condition.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.api.Condition;\n  return proto.models.proto.cofd.api.Condition.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.api.Condition} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.api.Condition}\n */\nproto.models.proto.cofd.api.Condition.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.api.Condition.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.api.Condition.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.api.Condition} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.api.Condition.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.api.Condition.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.api.Condition} returns this\n */\nproto.models.proto.cofd.api.Condition.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\ngoog.object.extend(exports, proto.models.proto.cofd.api);\n","// source: cofd.proto\n/**\n * @fileoverview\n * @enhanceable\n * @suppress {messageConventions} JS Compiler reports an error if a variable or\n *     field starts with 'MSG_' and isn't a translatable message.\n * @public\n */\n// GENERATED CODE -- DO NOT EDIT!\n/* eslint-disable */\n// @ts-nocheck\n\nvar jspb = require('google-protobuf');\nvar goog = jspb;\nvar global = Function('return this')();\n\ngoog.exportSymbol('proto.models.proto.cofd.ChangelingFields', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.Attack', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.Condition', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.Item', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.Merit', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.Skill', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CofdSheet.SystemFieldsCase', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.CoreFields', null, global);\ngoog.exportSymbol('proto.models.proto.cofd.MageFields', null, global);\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CoreFields = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.CoreFields, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CoreFields.displayName = 'proto.models.proto.cofd.CoreFields';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.MageFields = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.MageFields, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.MageFields.displayName = 'proto.models.proto.cofd.MageFields';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.ChangelingFields = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.ChangelingFields, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.ChangelingFields.displayName = 'proto.models.proto.cofd.ChangelingFields';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.CofdSheet.repeatedFields_, proto.models.proto.cofd.CofdSheet.oneofGroups_);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.displayName = 'proto.models.proto.cofd.CofdSheet';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet.Merit = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet.Merit, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.Merit.displayName = 'proto.models.proto.cofd.CofdSheet.Merit';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet.Condition = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet.Condition, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.Condition.displayName = 'proto.models.proto.cofd.CofdSheet.Condition';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet.Skill = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, proto.models.proto.cofd.CofdSheet.Skill.repeatedFields_, null);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet.Skill, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.Skill.displayName = 'proto.models.proto.cofd.CofdSheet.Skill';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet.Item = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet.Item, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.Item.displayName = 'proto.models.proto.cofd.CofdSheet.Item';\n}\n/**\n * Generated by JsPbCodeGenerator.\n * @param {Array=} opt_data Optional initial data array, typically from a\n * server response, or constructed directly in Javascript. The array is used\n * in place and becomes part of the constructed object. It is not cloned.\n * If no data is provided, the constructed object will be empty, but still\n * valid.\n * @extends {jspb.Message}\n * @constructor\n */\nproto.models.proto.cofd.CofdSheet.Attack = function(opt_data) {\n  jspb.Message.initialize(this, opt_data, 0, -1, null, null);\n};\ngoog.inherits(proto.models.proto.cofd.CofdSheet.Attack, jspb.Message);\nif (goog.DEBUG && !COMPILED) {\n  /**\n   * @public\n   * @override\n   */\n  proto.models.proto.cofd.CofdSheet.Attack.displayName = 'proto.models.proto.cofd.CofdSheet.Attack';\n}\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CoreFields.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CoreFields.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CoreFields} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CoreFields.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    integrity: jspb.Message.getFieldWithDefault(msg, 1, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CoreFields}\n */\nproto.models.proto.cofd.CoreFields.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CoreFields;\n  return proto.models.proto.cofd.CoreFields.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CoreFields} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CoreFields}\n */\nproto.models.proto.cofd.CoreFields.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setIntegrity(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CoreFields.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CoreFields.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CoreFields} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CoreFields.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getIntegrity();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 integrity = 1;\n * @return {number}\n */\nproto.models.proto.cofd.CoreFields.prototype.getIntegrity = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CoreFields} returns this\n */\nproto.models.proto.cofd.CoreFields.prototype.setIntegrity = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.MageFields.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.MageFields.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.MageFields} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.MageFields.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    widsom: jspb.Message.getFieldWithDefault(msg, 1, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.MageFields}\n */\nproto.models.proto.cofd.MageFields.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.MageFields;\n  return proto.models.proto.cofd.MageFields.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.MageFields} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.MageFields}\n */\nproto.models.proto.cofd.MageFields.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setWidsom(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.MageFields.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.MageFields.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.MageFields} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.MageFields.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getWidsom();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 widsom = 1;\n * @return {number}\n */\nproto.models.proto.cofd.MageFields.prototype.getWidsom = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.MageFields} returns this\n */\nproto.models.proto.cofd.MageFields.prototype.setWidsom = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.ChangelingFields.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.ChangelingFields.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.ChangelingFields} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.ChangelingFields.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    clarity: jspb.Message.getFieldWithDefault(msg, 1, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.ChangelingFields}\n */\nproto.models.proto.cofd.ChangelingFields.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.ChangelingFields;\n  return proto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.ChangelingFields} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.ChangelingFields}\n */\nproto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setClarity(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.ChangelingFields.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.ChangelingFields} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getClarity();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 clarity = 1;\n * @return {number}\n */\nproto.models.proto.cofd.ChangelingFields.prototype.getClarity = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.ChangelingFields} returns this\n */\nproto.models.proto.cofd.ChangelingFields.prototype.setClarity = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n\n/**\n * List of repeated fields within this message type.\n * @private {!Array<number>}\n * @const\n */\nproto.models.proto.cofd.CofdSheet.repeatedFields_ = [15,19,25,26];\n\n/**\n * Oneof group definitions for this message. Each group defines the field\n * numbers belonging to that group. When of these fields' value is set, all\n * other fields in the group are cleared. During deserialization, if multiple\n * fields are encountered for a group, only the last value seen will be kept.\n * @private {!Array<!Array<number>>}\n * @const\n */\nproto.models.proto.cofd.CofdSheet.oneofGroups_ = [[28,29,30]];\n\n/**\n * @enum {number}\n */\nproto.models.proto.cofd.CofdSheet.SystemFieldsCase = {\n  SYSTEM_FIELDS_NOT_SET: 0,\n  CORE: 28,\n  MAGE: 29,\n  CHANGELING: 30\n};\n\n/**\n * @return {proto.models.proto.cofd.CofdSheet.SystemFieldsCase}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getSystemFieldsCase = function() {\n  return /** @type {proto.models.proto.cofd.CofdSheet.SystemFieldsCase} */(jspb.Message.computeOneofCase(this, proto.models.proto.cofd.CofdSheet.oneofGroups_[0]));\n};\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    player: jspb.Message.getFieldWithDefault(msg, 2, \"\"),\n    campaign: jspb.Message.getFieldWithDefault(msg, 3, \"\"),\n    description: jspb.Message.getFieldWithDefault(msg, 4, \"\"),\n    strength: jspb.Message.getFieldWithDefault(msg, 6, 0),\n    dexterity: jspb.Message.getFieldWithDefault(msg, 7, 0),\n    stamina: jspb.Message.getFieldWithDefault(msg, 8, 0),\n    intelligence: jspb.Message.getFieldWithDefault(msg, 9, 0),\n    wits: jspb.Message.getFieldWithDefault(msg, 10, 0),\n    resolve: jspb.Message.getFieldWithDefault(msg, 11, 0),\n    presence: jspb.Message.getFieldWithDefault(msg, 12, 0),\n    manipulation: jspb.Message.getFieldWithDefault(msg, 13, 0),\n    composure: jspb.Message.getFieldWithDefault(msg, 14, 0),\n    physicalSkillsMap: (f = msg.getPhysicalSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [],\n    mentalSkillsMap: (f = msg.getMentalSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [],\n    socialSkillsMap: (f = msg.getSocialSkillsMap()) ? f.toObject(includeInstance, proto.models.proto.cofd.CofdSheet.Skill.toObject) : [],\n    meritsList: jspb.Message.toObjectList(msg.getMeritsList(),\n    proto.models.proto.cofd.CofdSheet.Merit.toObject, includeInstance),\n    conditionsList: jspb.Message.toObjectList(msg.getConditionsList(),\n    proto.models.proto.cofd.CofdSheet.Condition.toObject, includeInstance),\n    size: jspb.Message.getFieldWithDefault(msg, 20, 0),\n    health: jspb.Message.getFieldWithDefault(msg, 21, 0),\n    willpower: jspb.Message.getFieldWithDefault(msg, 22, 0),\n    experiencePoints: jspb.Message.getFieldWithDefault(msg, 23, 0),\n    beats: jspb.Message.getFieldWithDefault(msg, 24, 0),\n    itemsList: jspb.Message.toObjectList(msg.getItemsList(),\n    proto.models.proto.cofd.CofdSheet.Item.toObject, includeInstance),\n    attacksList: jspb.Message.toObjectList(msg.getAttacksList(),\n    proto.models.proto.cofd.CofdSheet.Attack.toObject, includeInstance),\n    otherDataMap: (f = msg.getOtherDataMap()) ? f.toObject(includeInstance, undefined) : [],\n    core: (f = msg.getCore()) && proto.models.proto.cofd.CoreFields.toObject(includeInstance, f),\n    mage: (f = msg.getMage()) && proto.models.proto.cofd.MageFields.toObject(includeInstance, f),\n    changeling: (f = msg.getChangeling()) && proto.models.proto.cofd.ChangelingFields.toObject(includeInstance, f)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet}\n */\nproto.models.proto.cofd.CofdSheet.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet;\n  return proto.models.proto.cofd.CofdSheet.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet}\n */\nproto.models.proto.cofd.CofdSheet.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setPlayer(value);\n      break;\n    case 3:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setCampaign(value);\n      break;\n    case 4:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setDescription(value);\n      break;\n    case 6:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setStrength(value);\n      break;\n    case 7:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDexterity(value);\n      break;\n    case 8:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setStamina(value);\n      break;\n    case 9:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setIntelligence(value);\n      break;\n    case 10:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setWits(value);\n      break;\n    case 11:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setResolve(value);\n      break;\n    case 12:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setPresence(value);\n      break;\n    case 13:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setManipulation(value);\n      break;\n    case 14:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setComposure(value);\n      break;\n    case 16:\n      var value = msg.getPhysicalSkillsMap();\n      reader.readMessage(value, function(message, reader) {\n        jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, \"\", new proto.models.proto.cofd.CofdSheet.Skill());\n         });\n      break;\n    case 17:\n      var value = msg.getMentalSkillsMap();\n      reader.readMessage(value, function(message, reader) {\n        jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, \"\", new proto.models.proto.cofd.CofdSheet.Skill());\n         });\n      break;\n    case 18:\n      var value = msg.getSocialSkillsMap();\n      reader.readMessage(value, function(message, reader) {\n        jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader, \"\", new proto.models.proto.cofd.CofdSheet.Skill());\n         });\n      break;\n    case 15:\n      var value = new proto.models.proto.cofd.CofdSheet.Merit;\n      reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader);\n      msg.addMerits(value);\n      break;\n    case 19:\n      var value = new proto.models.proto.cofd.CofdSheet.Condition;\n      reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Condition.deserializeBinaryFromReader);\n      msg.addConditions(value);\n      break;\n    case 20:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setSize(value);\n      break;\n    case 21:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setHealth(value);\n      break;\n    case 22:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setWillpower(value);\n      break;\n    case 23:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setExperiencePoints(value);\n      break;\n    case 24:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setBeats(value);\n      break;\n    case 25:\n      var value = new proto.models.proto.cofd.CofdSheet.Item;\n      reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Item.deserializeBinaryFromReader);\n      msg.addItems(value);\n      break;\n    case 26:\n      var value = new proto.models.proto.cofd.CofdSheet.Attack;\n      reader.readMessage(value,proto.models.proto.cofd.CofdSheet.Attack.deserializeBinaryFromReader);\n      msg.addAttacks(value);\n      break;\n    case 27:\n      var value = msg.getOtherDataMap();\n      reader.readMessage(value, function(message, reader) {\n        jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString, null, \"\", \"\");\n         });\n      break;\n    case 28:\n      var value = new proto.models.proto.cofd.CoreFields;\n      reader.readMessage(value,proto.models.proto.cofd.CoreFields.deserializeBinaryFromReader);\n      msg.setCore(value);\n      break;\n    case 29:\n      var value = new proto.models.proto.cofd.MageFields;\n      reader.readMessage(value,proto.models.proto.cofd.MageFields.deserializeBinaryFromReader);\n      msg.setMage(value);\n      break;\n    case 30:\n      var value = new proto.models.proto.cofd.ChangelingFields;\n      reader.readMessage(value,proto.models.proto.cofd.ChangelingFields.deserializeBinaryFromReader);\n      msg.setChangeling(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getPlayer();\n  if (f.length > 0) {\n    writer.writeString(\n      2,\n      f\n    );\n  }\n  f = message.getCampaign();\n  if (f.length > 0) {\n    writer.writeString(\n      3,\n      f\n    );\n  }\n  f = message.getDescription();\n  if (f.length > 0) {\n    writer.writeString(\n      4,\n      f\n    );\n  }\n  f = message.getStrength();\n  if (f !== 0) {\n    writer.writeInt32(\n      6,\n      f\n    );\n  }\n  f = message.getDexterity();\n  if (f !== 0) {\n    writer.writeInt32(\n      7,\n      f\n    );\n  }\n  f = message.getStamina();\n  if (f !== 0) {\n    writer.writeInt32(\n      8,\n      f\n    );\n  }\n  f = message.getIntelligence();\n  if (f !== 0) {\n    writer.writeInt32(\n      9,\n      f\n    );\n  }\n  f = message.getWits();\n  if (f !== 0) {\n    writer.writeInt32(\n      10,\n      f\n    );\n  }\n  f = message.getResolve();\n  if (f !== 0) {\n    writer.writeInt32(\n      11,\n      f\n    );\n  }\n  f = message.getPresence();\n  if (f !== 0) {\n    writer.writeInt32(\n      12,\n      f\n    );\n  }\n  f = message.getManipulation();\n  if (f !== 0) {\n    writer.writeInt32(\n      13,\n      f\n    );\n  }\n  f = message.getComposure();\n  if (f !== 0) {\n    writer.writeInt32(\n      14,\n      f\n    );\n  }\n  f = message.getPhysicalSkillsMap(true);\n  if (f && f.getLength() > 0) {\n    f.serializeBinary(16, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter);\n  }\n  f = message.getMentalSkillsMap(true);\n  if (f && f.getLength() > 0) {\n    f.serializeBinary(17, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter);\n  }\n  f = message.getSocialSkillsMap(true);\n  if (f && f.getLength() > 0) {\n    f.serializeBinary(18, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter);\n  }\n  f = message.getMeritsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      15,\n      f,\n      proto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter\n    );\n  }\n  f = message.getConditionsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      19,\n      f,\n      proto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter\n    );\n  }\n  f = message.getSize();\n  if (f !== 0) {\n    writer.writeInt32(\n      20,\n      f\n    );\n  }\n  f = message.getHealth();\n  if (f !== 0) {\n    writer.writeInt32(\n      21,\n      f\n    );\n  }\n  f = message.getWillpower();\n  if (f !== 0) {\n    writer.writeInt32(\n      22,\n      f\n    );\n  }\n  f = message.getExperiencePoints();\n  if (f !== 0) {\n    writer.writeInt32(\n      23,\n      f\n    );\n  }\n  f = message.getBeats();\n  if (f !== 0) {\n    writer.writeInt32(\n      24,\n      f\n    );\n  }\n  f = message.getItemsList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      25,\n      f,\n      proto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter\n    );\n  }\n  f = message.getAttacksList();\n  if (f.length > 0) {\n    writer.writeRepeatedMessage(\n      26,\n      f,\n      proto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter\n    );\n  }\n  f = message.getOtherDataMap(true);\n  if (f && f.getLength() > 0) {\n    f.serializeBinary(27, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString);\n  }\n  f = message.getCore();\n  if (f != null) {\n    writer.writeMessage(\n      28,\n      f,\n      proto.models.proto.cofd.CoreFields.serializeBinaryToWriter\n    );\n  }\n  f = message.getMage();\n  if (f != null) {\n    writer.writeMessage(\n      29,\n      f,\n      proto.models.proto.cofd.MageFields.serializeBinaryToWriter\n    );\n  }\n  f = message.getChangeling();\n  if (f != null) {\n    writer.writeMessage(\n      30,\n      f,\n      proto.models.proto.cofd.ChangelingFields.serializeBinaryToWriter\n    );\n  }\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.Merit.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet.Merit} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Merit.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    dots: jspb.Message.getFieldWithDefault(msg, 1, 0),\n    name: jspb.Message.getFieldWithDefault(msg, 2, \"\")\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet.Merit}\n */\nproto.models.proto.cofd.CofdSheet.Merit.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet.Merit;\n  return proto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet.Merit} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet.Merit}\n */\nproto.models.proto.cofd.CofdSheet.Merit.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDots(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet.Merit} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Merit.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getDots();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      2,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 dots = 1;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.getDots = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Merit} returns this\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.setDots = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n/**\n * optional string name = 2;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Merit} returns this\n */\nproto.models.proto.cofd.CofdSheet.Merit.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 2, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.Condition.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.Condition.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet.Condition} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Condition.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\")\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet.Condition}\n */\nproto.models.proto.cofd.CofdSheet.Condition.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet.Condition;\n  return proto.models.proto.cofd.CofdSheet.Condition.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet.Condition} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet.Condition}\n */\nproto.models.proto.cofd.CofdSheet.Condition.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.Condition.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet.Condition} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Condition.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Condition.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Condition} returns this\n */\nproto.models.proto.cofd.CofdSheet.Condition.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n\n/**\n * List of repeated fields within this message type.\n * @private {!Array<number>}\n * @const\n */\nproto.models.proto.cofd.CofdSheet.Skill.repeatedFields_ = [4];\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.Skill.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet.Skill} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Skill.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    dots: jspb.Message.getFieldWithDefault(msg, 1, 0),\n    name: jspb.Message.getFieldWithDefault(msg, 2, \"\"),\n    untrainedPenalty: jspb.Message.getFieldWithDefault(msg, 3, 0),\n    specializationsList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? undefined : f\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.CofdSheet.Skill.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet.Skill;\n  return proto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet.Skill} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet.Skill}\n */\nproto.models.proto.cofd.CofdSheet.Skill.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDots(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 3:\n      var value = /** @type {number} */ (reader.readSint32());\n      msg.setUntrainedPenalty(value);\n      break;\n    case 4:\n      var value = /** @type {string} */ (reader.readString());\n      msg.addSpecializations(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet.Skill} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Skill.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getDots();\n  if (f !== 0) {\n    writer.writeInt32(\n      1,\n      f\n    );\n  }\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      2,\n      f\n    );\n  }\n  f = message.getUntrainedPenalty();\n  if (f !== 0) {\n    writer.writeSint32(\n      3,\n      f\n    );\n  }\n  f = message.getSpecializationsList();\n  if (f.length > 0) {\n    writer.writeRepeatedString(\n      4,\n      f\n    );\n  }\n};\n\n\n/**\n * optional int32 dots = 1;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.getDots = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.setDots = function(value) {\n  return jspb.Message.setProto3IntField(this, 1, value);\n};\n\n\n/**\n * optional string name = 2;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 2, value);\n};\n\n\n/**\n * optional sint32 untrained_penalty = 3;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.getUntrainedPenalty = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.setUntrainedPenalty = function(value) {\n  return jspb.Message.setProto3IntField(this, 3, value);\n};\n\n\n/**\n * repeated string specializations = 4;\n * @return {!Array<string>}\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.getSpecializationsList = function() {\n  return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 4));\n};\n\n\n/**\n * @param {!Array<string>} value\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.setSpecializationsList = function(value) {\n  return jspb.Message.setField(this, 4, value || []);\n};\n\n\n/**\n * @param {string} value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.addSpecializations = function(value, opt_index) {\n  return jspb.Message.addToRepeatedField(this, 4, value, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.CofdSheet.Skill} returns this\n */\nproto.models.proto.cofd.CofdSheet.Skill.prototype.clearSpecializationsList = function() {\n  return this.setSpecializationsList([]);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.Item.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet.Item} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Item.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    description: jspb.Message.getFieldWithDefault(msg, 2, \"\"),\n    rules: jspb.Message.getFieldWithDefault(msg, 3, \"\")\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet.Item}\n */\nproto.models.proto.cofd.CofdSheet.Item.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet.Item;\n  return proto.models.proto.cofd.CofdSheet.Item.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet.Item} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet.Item}\n */\nproto.models.proto.cofd.CofdSheet.Item.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setDescription(value);\n      break;\n    case 3:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setRules(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet.Item} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Item.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getDescription();\n  if (f.length > 0) {\n    writer.writeString(\n      2,\n      f\n    );\n  }\n  f = message.getRules();\n  if (f.length > 0) {\n    writer.writeString(\n      3,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional string description = 2;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.getDescription = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.setDescription = function(value) {\n  return jspb.Message.setProto3StringField(this, 2, value);\n};\n\n\n/**\n * optional string rules = 3;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.getRules = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Item} returns this\n */\nproto.models.proto.cofd.CofdSheet.Item.prototype.setRules = function(value) {\n  return jspb.Message.setProto3StringField(this, 3, value);\n};\n\n\n\n\n\nif (jspb.Message.GENERATE_TO_OBJECT) {\n/**\n * Creates an object representation of this proto.\n * Field names that are reserved in JavaScript and will be renamed to pb_name.\n * Optional fields that are not set will be set to undefined.\n * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n * For the list of reserved names please see:\n *     net/proto2/compiler/js/internal/generator.cc#kKeyword.\n * @param {boolean=} opt_includeInstance Deprecated. whether to include the\n *     JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @return {!Object}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.toObject = function(opt_includeInstance) {\n  return proto.models.proto.cofd.CofdSheet.Attack.toObject(opt_includeInstance, this);\n};\n\n\n/**\n * Static version of the {@see toObject} method.\n * @param {boolean|undefined} includeInstance Deprecated. Whether to include\n *     the JSPB instance for transitional soy proto support:\n *     http://goto/soy-param-migration\n * @param {!proto.models.proto.cofd.CofdSheet.Attack} msg The msg instance to transform.\n * @return {!Object}\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Attack.toObject = function(includeInstance, msg) {\n  var f, obj = {\n    name: jspb.Message.getFieldWithDefault(msg, 1, \"\"),\n    dicePool: jspb.Message.getFieldWithDefault(msg, 2, 0),\n    damage: jspb.Message.getFieldWithDefault(msg, 3, 0),\n    range: jspb.Message.getFieldWithDefault(msg, 4, 0),\n    initiativeModifier: jspb.Message.getFieldWithDefault(msg, 5, 0),\n    size: jspb.Message.getFieldWithDefault(msg, 6, 0)\n  };\n\n  if (includeInstance) {\n    obj.$jspbMessageInstance = msg;\n  }\n  return obj;\n};\n}\n\n\n/**\n * Deserializes binary data (in protobuf wire format).\n * @param {jspb.ByteSource} bytes The bytes to deserialize.\n * @return {!proto.models.proto.cofd.CofdSheet.Attack}\n */\nproto.models.proto.cofd.CofdSheet.Attack.deserializeBinary = function(bytes) {\n  var reader = new jspb.BinaryReader(bytes);\n  var msg = new proto.models.proto.cofd.CofdSheet.Attack;\n  return proto.models.proto.cofd.CofdSheet.Attack.deserializeBinaryFromReader(msg, reader);\n};\n\n\n/**\n * Deserializes binary data (in protobuf wire format) from the\n * given reader into the given message object.\n * @param {!proto.models.proto.cofd.CofdSheet.Attack} msg The message object to deserialize into.\n * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n * @return {!proto.models.proto.cofd.CofdSheet.Attack}\n */\nproto.models.proto.cofd.CofdSheet.Attack.deserializeBinaryFromReader = function(msg, reader) {\n  while (reader.nextField()) {\n    if (reader.isEndGroup()) {\n      break;\n    }\n    var field = reader.getFieldNumber();\n    switch (field) {\n    case 1:\n      var value = /** @type {string} */ (reader.readString());\n      msg.setName(value);\n      break;\n    case 2:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDicePool(value);\n      break;\n    case 3:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setDamage(value);\n      break;\n    case 4:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setRange(value);\n      break;\n    case 5:\n      var value = /** @type {number} */ (reader.readSint32());\n      msg.setInitiativeModifier(value);\n      break;\n    case 6:\n      var value = /** @type {number} */ (reader.readInt32());\n      msg.setSize(value);\n      break;\n    default:\n      reader.skipField();\n      break;\n    }\n  }\n  return msg;\n};\n\n\n/**\n * Serializes the message to binary data (in protobuf wire format).\n * @return {!Uint8Array}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.serializeBinary = function() {\n  var writer = new jspb.BinaryWriter();\n  proto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter(this, writer);\n  return writer.getResultBuffer();\n};\n\n\n/**\n * Serializes the given message to binary data (in protobuf wire\n * format), writing to the given BinaryWriter.\n * @param {!proto.models.proto.cofd.CofdSheet.Attack} message\n * @param {!jspb.BinaryWriter} writer\n * @suppress {unusedLocalVariables} f is only used for nested messages\n */\nproto.models.proto.cofd.CofdSheet.Attack.serializeBinaryToWriter = function(message, writer) {\n  var f = undefined;\n  f = message.getName();\n  if (f.length > 0) {\n    writer.writeString(\n      1,\n      f\n    );\n  }\n  f = message.getDicePool();\n  if (f !== 0) {\n    writer.writeInt32(\n      2,\n      f\n    );\n  }\n  f = message.getDamage();\n  if (f !== 0) {\n    writer.writeInt32(\n      3,\n      f\n    );\n  }\n  f = message.getRange();\n  if (f !== 0) {\n    writer.writeInt32(\n      4,\n      f\n    );\n  }\n  f = message.getInitiativeModifier();\n  if (f !== 0) {\n    writer.writeSint32(\n      5,\n      f\n    );\n  }\n  f = message.getSize();\n  if (f !== 0) {\n    writer.writeInt32(\n      6,\n      f\n    );\n  }\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional int32 dice_pool = 2;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getDicePool = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setDicePool = function(value) {\n  return jspb.Message.setProto3IntField(this, 2, value);\n};\n\n\n/**\n * optional int32 damage = 3;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getDamage = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setDamage = function(value) {\n  return jspb.Message.setProto3IntField(this, 3, value);\n};\n\n\n/**\n * optional int32 range = 4;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getRange = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setRange = function(value) {\n  return jspb.Message.setProto3IntField(this, 4, value);\n};\n\n\n/**\n * optional sint32 initiative_modifier = 5;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getInitiativeModifier = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setInitiativeModifier = function(value) {\n  return jspb.Message.setProto3IntField(this, 5, value);\n};\n\n\n/**\n * optional int32 size = 6;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.getSize = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet.Attack} returns this\n */\nproto.models.proto.cofd.CofdSheet.Attack.prototype.setSize = function(value) {\n  return jspb.Message.setProto3IntField(this, 6, value);\n};\n\n\n/**\n * optional string name = 1;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getName = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setName = function(value) {\n  return jspb.Message.setProto3StringField(this, 1, value);\n};\n\n\n/**\n * optional string player = 2;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getPlayer = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setPlayer = function(value) {\n  return jspb.Message.setProto3StringField(this, 2, value);\n};\n\n\n/**\n * optional string campaign = 3;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getCampaign = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setCampaign = function(value) {\n  return jspb.Message.setProto3StringField(this, 3, value);\n};\n\n\n/**\n * optional string description = 4;\n * @return {string}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getDescription = function() {\n  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, \"\"));\n};\n\n\n/**\n * @param {string} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setDescription = function(value) {\n  return jspb.Message.setProto3StringField(this, 4, value);\n};\n\n\n/**\n * optional int32 strength = 6;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getStrength = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setStrength = function(value) {\n  return jspb.Message.setProto3IntField(this, 6, value);\n};\n\n\n/**\n * optional int32 dexterity = 7;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getDexterity = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setDexterity = function(value) {\n  return jspb.Message.setProto3IntField(this, 7, value);\n};\n\n\n/**\n * optional int32 stamina = 8;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getStamina = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setStamina = function(value) {\n  return jspb.Message.setProto3IntField(this, 8, value);\n};\n\n\n/**\n * optional int32 intelligence = 9;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getIntelligence = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setIntelligence = function(value) {\n  return jspb.Message.setProto3IntField(this, 9, value);\n};\n\n\n/**\n * optional int32 wits = 10;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getWits = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 10, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setWits = function(value) {\n  return jspb.Message.setProto3IntField(this, 10, value);\n};\n\n\n/**\n * optional int32 resolve = 11;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getResolve = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 11, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setResolve = function(value) {\n  return jspb.Message.setProto3IntField(this, 11, value);\n};\n\n\n/**\n * optional int32 presence = 12;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getPresence = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 12, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setPresence = function(value) {\n  return jspb.Message.setProto3IntField(this, 12, value);\n};\n\n\n/**\n * optional int32 manipulation = 13;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getManipulation = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 13, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setManipulation = function(value) {\n  return jspb.Message.setProto3IntField(this, 13, value);\n};\n\n\n/**\n * optional int32 composure = 14;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getComposure = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 14, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setComposure = function(value) {\n  return jspb.Message.setProto3IntField(this, 14, value);\n};\n\n\n/**\n * map<string, Skill> physical_skills = 16;\n * @param {boolean=} opt_noLazyCreate Do not create the map if\n * empty, instead returning `undefined`\n * @return {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getPhysicalSkillsMap = function(opt_noLazyCreate) {\n  return /** @type {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n      jspb.Message.getMapField(this, 16, opt_noLazyCreate,\n      proto.models.proto.cofd.CofdSheet.Skill));\n};\n\n\n/**\n * Clears values from the map. The map will be non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearPhysicalSkillsMap = function() {\n  this.getPhysicalSkillsMap().clear();\n  return this;};\n\n\n/**\n * map<string, Skill> mental_skills = 17;\n * @param {boolean=} opt_noLazyCreate Do not create the map if\n * empty, instead returning `undefined`\n * @return {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getMentalSkillsMap = function(opt_noLazyCreate) {\n  return /** @type {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n      jspb.Message.getMapField(this, 17, opt_noLazyCreate,\n      proto.models.proto.cofd.CofdSheet.Skill));\n};\n\n\n/**\n * Clears values from the map. The map will be non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearMentalSkillsMap = function() {\n  this.getMentalSkillsMap().clear();\n  return this;};\n\n\n/**\n * map<string, Skill> social_skills = 18;\n * @param {boolean=} opt_noLazyCreate Do not create the map if\n * empty, instead returning `undefined`\n * @return {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getSocialSkillsMap = function(opt_noLazyCreate) {\n  return /** @type {!jspb.Map<string,!proto.models.proto.cofd.CofdSheet.Skill>} */ (\n      jspb.Message.getMapField(this, 18, opt_noLazyCreate,\n      proto.models.proto.cofd.CofdSheet.Skill));\n};\n\n\n/**\n * Clears values from the map. The map will be non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearSocialSkillsMap = function() {\n  this.getSocialSkillsMap().clear();\n  return this;};\n\n\n/**\n * repeated Merit merits = 15;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Merit>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getMeritsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Merit>} */ (\n    jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Merit, 15));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Merit>} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setMeritsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 15, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Merit=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Merit}\n */\nproto.models.proto.cofd.CofdSheet.prototype.addMerits = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 15, opt_value, proto.models.proto.cofd.CofdSheet.Merit, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearMeritsList = function() {\n  return this.setMeritsList([]);\n};\n\n\n/**\n * repeated Condition conditions = 19;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Condition>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getConditionsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Condition>} */ (\n    jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Condition, 19));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Condition>} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setConditionsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 19, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Condition=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Condition}\n */\nproto.models.proto.cofd.CofdSheet.prototype.addConditions = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 19, opt_value, proto.models.proto.cofd.CofdSheet.Condition, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearConditionsList = function() {\n  return this.setConditionsList([]);\n};\n\n\n/**\n * optional int32 size = 20;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getSize = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 20, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setSize = function(value) {\n  return jspb.Message.setProto3IntField(this, 20, value);\n};\n\n\n/**\n * optional int32 health = 21;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getHealth = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 21, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setHealth = function(value) {\n  return jspb.Message.setProto3IntField(this, 21, value);\n};\n\n\n/**\n * optional int32 willpower = 22;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getWillpower = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 22, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setWillpower = function(value) {\n  return jspb.Message.setProto3IntField(this, 22, value);\n};\n\n\n/**\n * optional int32 experience_points = 23;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getExperiencePoints = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 23, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setExperiencePoints = function(value) {\n  return jspb.Message.setProto3IntField(this, 23, value);\n};\n\n\n/**\n * optional int32 beats = 24;\n * @return {number}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getBeats = function() {\n  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 24, 0));\n};\n\n\n/**\n * @param {number} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.setBeats = function(value) {\n  return jspb.Message.setProto3IntField(this, 24, value);\n};\n\n\n/**\n * repeated Item items = 25;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Item>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getItemsList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Item>} */ (\n    jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Item, 25));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Item>} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setItemsList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 25, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Item=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Item}\n */\nproto.models.proto.cofd.CofdSheet.prototype.addItems = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 25, opt_value, proto.models.proto.cofd.CofdSheet.Item, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearItemsList = function() {\n  return this.setItemsList([]);\n};\n\n\n/**\n * repeated Attack attacks = 26;\n * @return {!Array<!proto.models.proto.cofd.CofdSheet.Attack>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getAttacksList = function() {\n  return /** @type{!Array<!proto.models.proto.cofd.CofdSheet.Attack>} */ (\n    jspb.Message.getRepeatedWrapperField(this, proto.models.proto.cofd.CofdSheet.Attack, 26));\n};\n\n\n/**\n * @param {!Array<!proto.models.proto.cofd.CofdSheet.Attack>} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setAttacksList = function(value) {\n  return jspb.Message.setRepeatedWrapperField(this, 26, value);\n};\n\n\n/**\n * @param {!proto.models.proto.cofd.CofdSheet.Attack=} opt_value\n * @param {number=} opt_index\n * @return {!proto.models.proto.cofd.CofdSheet.Attack}\n */\nproto.models.proto.cofd.CofdSheet.prototype.addAttacks = function(opt_value, opt_index) {\n  return jspb.Message.addToRepeatedWrapperField(this, 26, opt_value, proto.models.proto.cofd.CofdSheet.Attack, opt_index);\n};\n\n\n/**\n * Clears the list making it empty but non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearAttacksList = function() {\n  return this.setAttacksList([]);\n};\n\n\n/**\n * map<string, string> other_data = 27;\n * @param {boolean=} opt_noLazyCreate Do not create the map if\n * empty, instead returning `undefined`\n * @return {!jspb.Map<string,string>}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getOtherDataMap = function(opt_noLazyCreate) {\n  return /** @type {!jspb.Map<string,string>} */ (\n      jspb.Message.getMapField(this, 27, opt_noLazyCreate,\n      null));\n};\n\n\n/**\n * Clears values from the map. The map will be non-null.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearOtherDataMap = function() {\n  this.getOtherDataMap().clear();\n  return this;};\n\n\n/**\n * optional CoreFields core = 28;\n * @return {?proto.models.proto.cofd.CoreFields}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getCore = function() {\n  return /** @type{?proto.models.proto.cofd.CoreFields} */ (\n    jspb.Message.getWrapperField(this, proto.models.proto.cofd.CoreFields, 28));\n};\n\n\n/**\n * @param {?proto.models.proto.cofd.CoreFields|undefined} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setCore = function(value) {\n  return jspb.Message.setOneofWrapperField(this, 28, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value);\n};\n\n\n/**\n * Clears the message field making it undefined.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearCore = function() {\n  return this.setCore(undefined);\n};\n\n\n/**\n * Returns whether this field is set.\n * @return {boolean}\n */\nproto.models.proto.cofd.CofdSheet.prototype.hasCore = function() {\n  return jspb.Message.getField(this, 28) != null;\n};\n\n\n/**\n * optional MageFields mage = 29;\n * @return {?proto.models.proto.cofd.MageFields}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getMage = function() {\n  return /** @type{?proto.models.proto.cofd.MageFields} */ (\n    jspb.Message.getWrapperField(this, proto.models.proto.cofd.MageFields, 29));\n};\n\n\n/**\n * @param {?proto.models.proto.cofd.MageFields|undefined} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setMage = function(value) {\n  return jspb.Message.setOneofWrapperField(this, 29, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value);\n};\n\n\n/**\n * Clears the message field making it undefined.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearMage = function() {\n  return this.setMage(undefined);\n};\n\n\n/**\n * Returns whether this field is set.\n * @return {boolean}\n */\nproto.models.proto.cofd.CofdSheet.prototype.hasMage = function() {\n  return jspb.Message.getField(this, 29) != null;\n};\n\n\n/**\n * optional ChangelingFields changeling = 30;\n * @return {?proto.models.proto.cofd.ChangelingFields}\n */\nproto.models.proto.cofd.CofdSheet.prototype.getChangeling = function() {\n  return /** @type{?proto.models.proto.cofd.ChangelingFields} */ (\n    jspb.Message.getWrapperField(this, proto.models.proto.cofd.ChangelingFields, 30));\n};\n\n\n/**\n * @param {?proto.models.proto.cofd.ChangelingFields|undefined} value\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n*/\nproto.models.proto.cofd.CofdSheet.prototype.setChangeling = function(value) {\n  return jspb.Message.setOneofWrapperField(this, 30, proto.models.proto.cofd.CofdSheet.oneofGroups_[0], value);\n};\n\n\n/**\n * Clears the message field making it undefined.\n * @return {!proto.models.proto.cofd.CofdSheet} returns this\n */\nproto.models.proto.cofd.CofdSheet.prototype.clearChangeling = function() {\n  return this.setChangeling(undefined);\n};\n\n\n/**\n * Returns whether this field is set.\n * @return {boolean}\n */\nproto.models.proto.cofd.CofdSheet.prototype.hasChangeling = function() {\n  return jspb.Message.getField(this, 30) != null;\n};\n\n\ngoog.object.extend(exports, proto.models.proto.cofd);\n"],"sourceRoot":""} \ No newline at end of file diff --git a/static/scripts/build/blah.bundle.js b/static/scripts/build/blah.bundle.js new file mode 100644 index 0000000..0504145 --- /dev/null +++ b/static/scripts/build/blah.bundle.js @@ -0,0 +1,23 @@ +(self["webpackChunk"] = self["webpackChunk"] || []).push([["blah"],{ + +/***/ "./src/blah.ts": +/*!*********************!*\ + !*** ./src/blah.ts ***! + \*********************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var cofd_api_pb_1 = __webpack_require__(/*! ../_proto/cofd_api_pb */ "./_proto/cofd_api_pb.js"); +var x = new cofd_api_pb_1.UpdateSkillValueRequest(); +x.setCharacterId(1); +x.setCharacterUsername("guy"); +console.log("hello", x); + + +/***/ }) + +}, +0,[["./src/blah.ts","runtime","vendors-node_modules_google-protobuf_google-protobuf_js","_proto_cofd_api_pb_js"]]]); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly8vLi9zcmMvYmxhaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUVBLGdHQUFnRTtBQUVoRSxJQUFJLENBQUMsR0FBRyxJQUFJLHFDQUF1QixFQUFFLENBQUM7QUFDdEMsQ0FBQyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNwQixDQUFDLENBQUMsb0JBQW9CLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDOUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMiLCJmaWxlIjoiYmxhaC5idW5kbGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBncnBjIH0gZnJvbSBcIkBpbXByb2JhYmxlLWVuZy9ncnBjLXdlYlwiO1xuaW1wb3J0IHsgQ29mZEFwaSB9IGZyb20gXCIuLi9fcHJvdG8vY29mZF9hcGlfcGJfc2VydmljZVwiO1xuaW1wb3J0IHsgVXBkYXRlU2tpbGxWYWx1ZVJlcXVlc3QgfSBmcm9tIFwiLi4vX3Byb3RvL2NvZmRfYXBpX3BiXCI7XG5cbmxldCB4ID0gbmV3IFVwZGF0ZVNraWxsVmFsdWVSZXF1ZXN0KCk7XG54LnNldENoYXJhY3RlcklkKDEpO1xueC5zZXRDaGFyYWN0ZXJVc2VybmFtZShcImd1eVwiKTtcbmNvbnNvbGUubG9nKFwiaGVsbG9cIiwgeCk7XG4iXSwic291cmNlUm9vdCI6IiJ9 \ No newline at end of file diff --git a/static/scripts/build/index.bundle.js b/static/scripts/build/index.bundle.js new file mode 100644 index 0000000..ca8afeb --- /dev/null +++ b/static/scripts/build/index.bundle.js @@ -0,0 +1,21 @@ +(self["webpackChunk"] = self["webpackChunk"] || []).push([["index"],{ + +/***/ "./src/index.ts": +/*!**********************!*\ + !*** ./src/index.ts ***! + \**********************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var cofd_api_pb_1 = __webpack_require__(/*! ../_proto/cofd_api_pb */ "./_proto/cofd_api_pb.js"); +var x = new cofd_api_pb_1.UpdateSkillValueRequest(); +console.log("hello from index"); + + +/***/ }) + +}, +0,[["./src/index.ts","runtime","vendors-node_modules_google-protobuf_google-protobuf_js","_proto_cofd_api_pb_js"]]]); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly8vLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFFQSxnR0FBZ0U7QUFFaEUsSUFBSSxDQUFDLEdBQUcsSUFBSSxxQ0FBdUIsRUFBRSxDQUFDO0FBS3RDLE9BQU8sQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQyIsImZpbGUiOiJpbmRleC5idW5kbGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBncnBjIH0gZnJvbSBcIkBpbXByb2JhYmxlLWVuZy9ncnBjLXdlYlwiO1xuLy8gaW1wb3J0IHsgQ29mZEFwaSB9IGZyb20gXCIuLi9fcHJvdG8vY29mZF9hcGlfcGJfc2VydmljZVwiO1xuaW1wb3J0IHsgVXBkYXRlU2tpbGxWYWx1ZVJlcXVlc3QgfSBmcm9tIFwiLi4vX3Byb3RvL2NvZmRfYXBpX3BiXCI7XG5cbmxldCB4ID0gbmV3IFVwZGF0ZVNraWxsVmFsdWVSZXF1ZXN0KCk7XG4vLyB4LnNldENoYXJhY3RlcklkKDEpO1xuLy8geC5zZXRDaGFyYWN0ZXJVc2VybmFtZShcImd1eVwiKTtcbi8vIGNvbnNvbGUubG9nKFwiaGVsbG9cIiwgeCk7XG5cbmNvbnNvbGUubG9nKFwiaGVsbG8gZnJvbSBpbmRleFwiKTtcbiJdLCJzb3VyY2VSb290IjoiIn0= \ No newline at end of file diff --git a/static/scripts/build/runtime.bundle.js b/static/scripts/build/runtime.bundle.js new file mode 100644 index 0000000..49975eb --- /dev/null +++ b/static/scripts/build/runtime.bundle.js @@ -0,0 +1,146 @@ +/******/ (() => { // webpackBootstrap +/******/ "use strict"; +/******/ var __webpack_modules__ = ({}); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ if(__webpack_module_cache__[moduleId]) { +/******/ return __webpack_module_cache__[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ // no module.id needed +/******/ // no module.loaded needed +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = __webpack_modules__; +/******/ +/******/ // the startup function +/******/ // It's empty as some runtime module handles the default behavior +/******/ __webpack_require__.x = x => {} +/************************************************************************/ +/******/ /* webpack/runtime/global */ +/******/ (() => { +/******/ __webpack_require__.g = (function() { +/******/ if (typeof globalThis === 'object') return globalThis; +/******/ try { +/******/ return this || new Function('return this')(); +/******/ } catch (e) { +/******/ if (typeof window === 'object') return window; +/******/ } +/******/ })(); +/******/ })(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop) +/******/ })(); +/******/ +/******/ /* webpack/runtime/jsonp chunk loading */ +/******/ (() => { +/******/ // no baseURI +/******/ +/******/ // object to store loaded and loading chunks +/******/ // undefined = chunk not loaded, null = chunk preloaded/prefetched +/******/ // Promise = chunk loading, 0 = chunk loaded +/******/ var installedChunks = { +/******/ "runtime": 0 +/******/ }; +/******/ +/******/ var deferredModules = [ +/******/ +/******/ ]; +/******/ // no chunk on demand loading +/******/ +/******/ // no prefetching +/******/ +/******/ // no preloaded +/******/ +/******/ // no HMR +/******/ +/******/ // no HMR manifest +/******/ +/******/ var checkDeferredModules = x => {}; +/******/ +/******/ // install a JSONP callback for chunk loading +/******/ var webpackJsonpCallback = (parentChunkLoadingFunction, data) => { +/******/ var [chunkIds, moreModules, runtime, executeModules] = data; +/******/ // add "moreModules" to the modules object, +/******/ // then flag all "chunkIds" as loaded and fire callback +/******/ var moduleId, chunkId, i = 0, resolves = []; +/******/ for(;i < chunkIds.length; i++) { +/******/ chunkId = chunkIds[i]; +/******/ if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) { +/******/ resolves.push(installedChunks[chunkId][0]); +/******/ } +/******/ installedChunks[chunkId] = 0; +/******/ } +/******/ for(moduleId in moreModules) { +/******/ if(__webpack_require__.o(moreModules, moduleId)) { +/******/ __webpack_require__.m[moduleId] = moreModules[moduleId]; +/******/ } +/******/ } +/******/ if(runtime) runtime(__webpack_require__); +/******/ if(parentChunkLoadingFunction) parentChunkLoadingFunction(data); +/******/ while(resolves.length) { +/******/ resolves.shift()(); +/******/ } +/******/ +/******/ // add entry modules from loaded chunk to deferred list +/******/ if(executeModules) deferredModules.push.apply(deferredModules, executeModules); +/******/ +/******/ // run deferred modules when all chunks ready +/******/ return checkDeferredModules(); +/******/ } +/******/ +/******/ var chunkLoadingGlobal = self["webpackChunk"] = self["webpackChunk"] || []; +/******/ chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0)); +/******/ chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal)); +/******/ +/******/ function checkDeferredModulesImpl() { +/******/ var result; +/******/ for(var i = 0; i < deferredModules.length; i++) { +/******/ var deferredModule = deferredModules[i]; +/******/ var fulfilled = true; +/******/ for(var j = 1; j < deferredModule.length; j++) { +/******/ var depId = deferredModule[j]; +/******/ if(installedChunks[depId] !== 0) fulfilled = false; +/******/ } +/******/ if(fulfilled) { +/******/ deferredModules.splice(i--, 1); +/******/ result = __webpack_require__(__webpack_require__.s = deferredModule[0]); +/******/ } +/******/ } +/******/ if(deferredModules.length === 0) { +/******/ __webpack_require__.x(); +/******/ __webpack_require__.x = x => {}; +/******/ } +/******/ return result; +/******/ } +/******/ var startup = __webpack_require__.x; +/******/ __webpack_require__.x = () => { +/******/ // reset startup function so it can be called again when more startup code is added +/******/ __webpack_require__.x = startup || (x => {}); +/******/ return (checkDeferredModules = checkDeferredModulesImpl)(); +/******/ }; +/******/ })(); +/******/ +/************************************************************************/ +/******/ // run startup +/******/ return __webpack_require__.x(); +/******/ })() +; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/static/scripts/build/vendors-node_modules_google-protobuf_google-protobuf_js.bundle.js b/static/scripts/build/vendors-node_modules_google-protobuf_google-protobuf_js.bundle.js new file mode 100644 index 0000000..0330d73 --- /dev/null +++ b/static/scripts/build/vendors-node_modules_google-protobuf_google-protobuf_js.bundle.js @@ -0,0 +1,537 @@ +(self["webpackChunk"] = self["webpackChunk"] || []).push([["vendors-node_modules_google-protobuf_google-protobuf_js"],{ + +/***/ "../../node_modules/google-protobuf/google-protobuf.js": +/*!*************************************************************!*\ + !*** ../../node_modules/google-protobuf/google-protobuf.js ***! + \*************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.findInternal=function(a,b,c){a instanceof String&&(a=String(a));for(var d=a.length,e=0;e=e}},"es6","es3");$jscomp.polyfill("Array.prototype.find",function(a){return a?a:function(a,c){return $jscomp.findInternal(this,a,c).v}},"es6","es3"); +$jscomp.polyfill("String.prototype.startsWith",function(a){return a?a:function(a,c){var b=$jscomp.checkStringArgs(this,a,"startsWith");a+="";var e=b.length,f=a.length;c=Math.max(0,Math.min(c|0,b.length));for(var g=0;g=f}},"es6","es3"); +$jscomp.polyfill("String.prototype.repeat",function(a){return a?a:function(a){var b=$jscomp.checkStringArgs(this,null,"repeat");if(0>a||1342177279>>=1)b+=b;return d}},"es6","es3");var COMPILED=!0,goog=goog||{};goog.global=this||self;goog.isDef=function(a){return void 0!==a};goog.isString=function(a){return"string"==typeof a};goog.isBoolean=function(a){return"boolean"==typeof a}; +goog.isNumber=function(a){return"number"==typeof a};goog.exportPath_=function(a,b,c){a=a.split(".");c=c||goog.global;a[0]in c||"undefined"==typeof c.execScript||c.execScript("var "+a[0]);for(var d;a.length&&(d=a.shift());)!a.length&&goog.isDef(b)?c[d]=b:c=c[d]&&c[d]!==Object.prototype[d]?c[d]:c[d]={}}; +goog.define=function(a,b){if(!COMPILED){var c=goog.global.CLOSURE_UNCOMPILED_DEFINES,d=goog.global.CLOSURE_DEFINES;c&&void 0===c.nodeType&&Object.prototype.hasOwnProperty.call(c,a)?b=c[a]:d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)&&(b=d[a])}return b};goog.FEATURESET_YEAR=2012;goog.DEBUG=!0;goog.LOCALE="en";goog.TRUSTED_SITE=!0;goog.STRICT_MODE_COMPATIBLE=!1;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1; +goog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var c=a;(c=c.substring(0,c.lastIndexOf(".")))&&!goog.getObjectByName(c);)goog.implicitNamespaces_[c]=!0}goog.exportPath_(a,b)}; +goog.getScriptNonce=function(a){if(a&&a!=goog.global)return goog.getScriptNonce_(a.document);null===goog.cspNonce_&&(goog.cspNonce_=goog.getScriptNonce_(goog.global.document));return goog.cspNonce_};goog.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;goog.cspNonce_=null;goog.getScriptNonce_=function(a){return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/; +goog.module=function(a){if(!goog.isString(a)||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide."); +if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)}; +goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;goog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG}; +goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1}; +goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0}; +goog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error('Module with namespace "'+a+'" already exists.');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error('Module with namespace "'+ +a+'" has been loaded incorrectly.');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){}; +COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&goog.isDefAndNotNull(goog.getObjectByName(a))},goog.implicitNamespaces_={"goog.module":!0});goog.getObjectByName=function(a,b){a=a.split(".");b=b||goog.global;for(var c=0;c>>0);goog.uidCounter_=0;goog.getHashCode=goog.getUid; +goog.removeHashCode=goog.removeUid;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)}; +goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2{"use strict";class X{constructor(){if(new.target!=String)throw 1;this.x=42}}let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof String))throw 1;for(const a of[2,3]){if(a==2)continue;function f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()==3}})()')}); +a("es7",function(){return b("2 ** 2 == 4")});a("es8",function(){return b("async () => 1, true")});a("es9",function(){return b("({...rest} = {}), true")});a("es_next",function(){return!1});return{target:c,map:d}},goog.Transpiler.prototype.needsTranspile=function(a,b){if("always"==goog.TRANSPILE)return!0;if("never"==goog.TRANSPILE)return!1;if(!this.requiresTranspilation_){var c=this.createRequiresTranspilation_();this.requiresTranspilation_=c.map;this.transpilationTarget_=this.transpilationTarget_|| +c.target}if(a in this.requiresTranspilation_)return this.requiresTranspilation_[a]?!0:!goog.inHtmlDocument_()||"es6"!=b||"noModule"in goog.global.document.createElement("script")?!1:!0;throw Error("Unknown language mode: "+a);},goog.Transpiler.prototype.transpile=function(a,b){return goog.transpile_(a,b,this.transpilationTarget_)},goog.transpiler_=new goog.Transpiler,goog.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_={}; +this.idToPath_={};this.written_={};this.loadingDeps_=[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory(goog.transpiler_);this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){b=[];for(var e=0;e\x3c/script>";b.write(goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createHTML(d):d)}else{var e=b.createElement("script");e.defer=goog.Dependency.defer_;e.async=!1;e.type="text/javascript";(d=goog.getScriptNonce())&&e.setAttribute("nonce",d);goog.DebugLoader_.IS_OLD_IE_? +(a.pause(),e.onreadystatechange=function(){if("loaded"==e.readyState||"complete"==e.readyState)a.loaded(),a.resume()}):e.onload=function(){e.onload=null;a.loaded()};e.src=goog.TRUSTED_TYPES_POLICY_?goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path):this.path;b.head.appendChild(e)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."), +a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e)},goog.inherits(goog.Es6ModuleDependency,goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(a,b){a=b?'